Cara Menghilangkan Notifikasi User Account Control (UAC)

Sadar dengan kerentanan Windows XP, Microsoft semakin bekerja keras mengembangkan metode proteksi sistem Windows generasi berikutnya. Sehingga nantinya diharapkan agar sistem lebih kokoh dalam menghadapi segala kemungkinan bahaya akhibat program tak bertanggung jawab yang berjalan dalam sistem. Untuk itu, Microsoft mulai menerapkan sebuah ide, User Account Control (UAC) yang harus senantiasa diperhatikan pada saat eksekusi program.

Dengan kemunculan jendela notifikasi User Account Control(UAC), sistem operasi dapat memastikan apakah pengguna benar-benar mengenal program tersebut. Program ini dinilai perlu dipastikan kredibilitasnya karena hendak mengakses bagian sentimental dari sistem. Apabila program diizinkan, hak akses program tersebut memungkinkannya untuk melakukan akses terhadap lingkungan sensitif sistem operasi. Misalnya saja, normalnya program akan error jika memodifikasi/membuat file di C:\, akan tetapi jikaprogram dijalankan sebagai Administrator, semua akan berjalan lancar.

Meski fitur ini sangat membantu, kadang notifikasi ini juga terasa menjengkelkan bagi beberapa orang, karena dinilai terlalu bertele-tele alias kurang praktis. Sebenarnya, sistem yang tidak terlalu sering diapakai untuk mengakses internet memiliki peluang rendah untuk terinfeksi malware. Mungkin menghilangkan notifikasi UAC dalam hal demikian itu bukan menjadi sebuah masalah.

Lalu, bagaimana cara menghilangkan/menyembunyikan jendela notifikasi User Account Control tersebut?
1. Buka salah satu program sebagai administrator. Bisa dilakukan dengan klik kanan shortcut programnya->Run as administrator.
2. Coba perhatikan benar-benar, Di pojokan jendela notifikasi akan tertera link tulisan berwarna biru bertuliskan "Change when these notification appears". Klik saja tulisan ini.

Tahap 1 dan 2 bisa juga dilakukan melalui Control Panel. Carilah pengaturan bernama "Change User Account Control settings".

3. Jika anda ingin menyembunyikan segala jenis notifikasi User Account Control, arahkan skala peraturan ke arah paling bawah, setingkatdengan "Never notify". Jika kebalikannya yang dikehendaki, arahkan skala ke arah lebih atas.

Selamat mencoba :)

Read more

Pengertian File System dan Beberapa Macam File System

File system atau sistem berkas adalah mekanisme manajemen berkas dalam suatu media penyimpanan dengan tujuan untuk memudahkan akses berkas tersebut secara efektif serta efisien. Dalam kerjanya, sebuah file system memiliki beberapa subfungsi/subsystem untuk mencapai target manajemen efektif dan efisien.

File system diimplementasikan oleh sistem operasi untuk mengatasi keterbatasan kemampuan dari media penyimpanan tersebut. Sehingga sebuah berkas di dalam media penyimpanan bukan hanya dapat disimpan datanya saja. Karena yang terpenting, file system juga akan mengatur bagaimana nama berkas disimpan.

Sebuah berkas bukan saja terdiri atas data, namun juga komponen metadata/informasi mengenai data yang bersangkutan. Apabila dijabarkan, sebuah berkas paling tidak terkandung komponen dasar sebagai berikut:
- data
- nama berkas
- ukuran berkas
- atribut berkas  (misalnya read only atau hidden)
- pemilik berkas
- informasi berkas (waktu pembuatan, waktu modifikasi, ...)

Bukan hanya itu, file system juga harus mampu mengalokasikan seluruh jenis data di atas di dalam disk. Ini karena kemampuan abstrak disk yang terbatas hanya pada pembacaan dan penulisan data.

Sebuah media penyimpanan masa kini umumnya bermodel alokasi berbasis sektoral. Setiap sektor menampung data sebanyak 512 byte. Setiap sektor akan dialamatkan dengan logical block address 0, 1, 2, 3, ...., dst.

Data yang tersimpan dalam sektor  bersifat universal jika dilihat dari sudut pandang media penyimpanan. Artinya, media memandang semua data tersebut sama saja. Jadi, media tidak mampu membedakan apakah data di dalam sektor X merupakan bagian data dari suatu berkas, data mengenai nama berkas, atau mungkin data informasi mengenai berkas. Nah, tugas filesystem adalah mengatasi masalah mendasar tersebut.

Ada banyak jenis filesystem yang bisa ditemui. Perbedaan besar diantara mereka terletak pada bagaimana file system melakukan alokasi komponen berkas ke dalam sektor media penyimpanan, Namun secara garis besar jenis data yang disimpan tetap sama:
- data berkas
- nama berkas
- informasi mengenai berkas.

Komponen informasi mengenai berkas juga banyak memiliki perbedaan disamping kesamaan. Sebagai contoh, beberapa perbandingan file system EXT dan FAT pada aspek informasi file akan nampak seperti berikut.
Informasi mengenai berkas yang sama-sama ada:
- atribut file
- waktu pembuatan file
- waktu modifikasi file
Informasi yang hanya ada di EXT *:
- pemilik file
- hak akses file

* Kedua informasi di atas ada karena semua file dalam EXT bisa dikhususkan untuk dapat dipakai untuk pemakai tertentu saja, sedangkan semua file dalam FAT bebas diakses siapa pun.

Ada banyak sekali macam filesystem. Sebenarnya kesemua jenis ini bisa saja dipakai oleh sistem operasi manapun, akan tetapi beberapa jenis file system memang dipersembahkan khusus untuk sistem operasi tertentu. Untuk dapat menggunakan file system lain, terkadang kita harus menginstall driver untuk file system tersebut, karena sistem operasi belum menyediakannya. Berikut daftar sistem berkas yang dapat anda ketahui:

FAT (File Allocation Table)
Adalah file system pertama yang dikembangkan oleh Microsoft untuk sistem CP/M dan DOS. Seiring dengan tumbuhnya Microsoft, FAT generasi awal sering disebut sebagai FAT12, lalu dilakukan diversifikasi varian FAT16 dan FAT32 yang dapat digunakan untuk kapasitas media lebih besar.

FAT12
FAT12 merupakan sistem berkas yang menggunakan unit alokasi yang memiliki batas hingga 12-bit. File System ini hanya dapat menampung maksimum hanya 12^2 unit alokasi saja atau sebanyak 4096 buah. FAT12 pertama kali digunakan pada Sistem Operasi MS-DOS. Karena kapasitasnya sedikit yakni hanya 32 MB, maka FAT12 hanya digunakan sebagai file system pada media penyimpanan floppy disk.

FAT16
FAT16 merupakan sistem berkas yang menggunakan unit alokasi yang memiliki batas hingga 16-bit. File System ini dapat menampung maksimum 2^16 unit alokasi atau sebanyak 65536. Kapasitas File System ini sebanyak 4 GB, jauh melebihi versi sebelumnya yang hanya 32 MB. Ukuran unit alokasi yang digunakan FAT16 tergantung kapasitas partisi harddisk yang akan diformat. Jika kapasitasnya kurang dari 16 MB, maka yang akan digunakan adalah FAT12. Jika melebihi 16 MB maka yang digunakan adalah FAT16.

FAT32
FAT32 merupakan sistem berkas yang menggunakan unit alokasi yang memiliki batas hingga 32-bit. File System ini dapat menampung maksimum 2^32 unit alokasi atau sebanyak 4294967296. Meskipun demikian, dalam implementasinya, jumlah unit alokasi yang dapat dialamati oleh FAT32 hanya 2^28 atau 268435456 buah. FAT32 pertama kali dikenalkan pada Sistem Operasi Windows 95 OSR2. Pada Sistem Operasi Windows NT 5.x ke atas, hanya mengizinkan pembuatan partisi FAT32 hingga 32 GB. Jika partisinya melebihi 32 GB, maka yang akan digunakan adalah File System NTFS.

exFAT
exFAT singkatan dari Extended File Allocation Table atau sering disebut sebagai FAT64. exFAT merupakan sistem berkas proprietary yang cocok untuk digunakan oleh media-media penyimpanan berbasis memori flash.


NTFS (New Technology File System)

NTFS merupakan File System yang memiliki sebuah desain sederhana namun memiliki kemampuan yang lebih baik dibandingkan FAT File System. NTFS pertama kali dikenalkan Microsoft pada Sistem Operasi Windows NT dan mendukung Sistem Operasi yang terbaru yaitu Windows 7. Sejak pertama kali dibuat hingga sekarang, NTFS telah mengalami perkembangan. Beberapa versi NTFS antara lain:

NTFS versi 1.0
NTFS ini datang bersama dengan Windows NT 3.1. Versi ini menawarkan fungsi yang sangat dasar, tetapi sudah jauh lebih baik dibandingkan FAT File System.

NTFS versi 1.1
NTFS ini datang bersama dengan Windows NT 3.50. Versi ini menambahkan dukungan terhadap pengaturan akses secara diskrit (discretionary access control).

NTFS versi 1.2
NTFS ini datang bersama dengan Windows NT 4.0. Versi ini menambahkan dukungan terhadap auditing setiap berkas dan juga kompresi transparan.

NTFS versi 2.0
NTFS ini tidak dirilis secara umum, karena berbagai kendala yang dialaminya, yang tidak diumumkan oleh Microsoft. Microsoft menggagalkan proyek NTFS 2.0 dan langsung menginjak NTFS 3.0

NTFS versi 3.0
NTFS ini datang bersama dengan Windows 2000. Versi ini menawarkan banyak peningkatan dibandingkan dengan versi sebelumnya. Di antaranya adalah penetapan kuota kepada setiap pengguna, Encrypting File System (EFS), sistem keamanan yang dapat diatur dari server pusat, fitur indeksasi terhadap properti dan isi setiap berkas, dan lain-lain. Selain itu, NTFS 3.0 juga menawarkan dukungan kepada struktur GUID Partition Table dan Logical Disk Management.

NTFS versi 3.1
NTFS ini datang bersama dengan Windows XP SP1 dan Windows Server 2003. Versi ini menawarkan perbaikan yang minor yang terjadi dalam versi sebelumnya (khususnya di bidang performa), dan juga penggantian algoritma enkripsi yang digunakan oleh EFS dari DESX atau 3DES menjadi AES-256.

Ext(Extended File System)
Ext 2 (2nd Extended)
Ext 2 merupakan tipe file system yang paling tua yang masih ada. File system ini pertama kali dikenalkan pada tahun 1993. Ext 2 adalah file system yang paling ampuh di linux dan menjadi dasar dari segala distribusi linux. Pada Ext 2 file system, file data disimpan sebagai data blok. Data blok ini mempunyai panjang yang sama dan meskipun panjangnya bervariasi di antara Ext 2 file system, besar blok tersebut ditentukan pada saat file system dibuat dengan mk2fs. Jika besar blok adalah 1024 bytes, maka file dengan besar 1025 bytes akan memakai 2 blok. Ext 2 File System menyimpan data secara hirarki standar yang banyak digunakan oleh sistem operasi. Data tersimpan di dalam file, file tersimpan di dalam direktori. Sebuah direktori bisa mencakup file dan direktori lagi di dalamnya yang disebut sub direktori.

Ext 3 (3rd Extended)
Ext 3 merupakan peningkatan dari Ext 2 File System. Beberapa peningkatan yang ada antara lain:

Journaling:
Dengan menggunakan journaling, maka waktu recovery pada shut down yang mendadak tidak akan selama pada Ext 2.

Integritas Data:
Ext 3 menjamin adanya integritas data setelah terjadi kerusakan atau unclean shut down. Ext 3 memungkinkan kita memilih jenis dan tipe proteksi dari data.

Kecepatan:
Daripada menulis data lebih dari sekali, Ext 3 mempunyai throughput yang lebih besar daripada Ext 2 karena Ext 3 memaksimalkan pergerakan head harddisk. Kita bisa memilih tiga jurnal mode untuk memaksimalkan kecepatan, tetapi integritas data tidak terjamin.

Mudah Dilakukan Migrasi:
Kita dapat melakukan migrasi atau konversi dari Ext 2 ke Ext 3 tanpa harus melakukan format ulang pada harddisk.

Di samping keunggulan di atas, Ext 3 juga memiliki kekurangan. Dengan adanya fitur journaling, maka membutuhkan memori yang lebih dan memperlambat operasi I/O.

Ext 4 (4th Extended)
Ext 4 dirilis secara komplit dan stabil berawal dari kernel 2.6.28. Jadi, apabila distro yang secara default memiliki kernel tersebut atau di atasnya secara otomatis system sudah support Ext 4. Apabila masih menggunakan Ext 3, dapat dilakukan konversi ke ext 4 dengan beberapa langkah yang tidak terlalu rumit.

Keuntungan menggunakan Ext 4 ini adalah mempunyai pengalamatan 48-bit blok yang artinya dia akan mempunyai 1 EiB = 1.048.576 TB ukuran maksimum file system dengan ukuran 16 TB untuk maksimum file sizenya, fast fsck, journal checksumming, defragmentation support.

Selain dari beberapa macam file system di atas, ada pula sistem berkas yang masih jarang dikenal. Ada CDFS(ISO 9660), UDF, HPFS, ReiserFS, BtrFS, BeFS, BFS, MFS, LEAN, dan masih banyak lagi.

Referensi : https://dhanz3rd.wordpress.com/2010/12/14/file-system-di-windows-dan-linux/

Read more

Pengertian Spinlock dan Implementasinya

Multitasking adalah tantangan baru bagi programmer sistem operasi. Ada banyak macam resource yang harus digunakan oleh semua thread, namun jumlahnya terbatas, dan tidak mungkin diakses bersamaan. Untuk itu, masing-masing thread harus dapat diatur agar dapat mengaksesnya secara bergiliran secara sinkron.

Dalam hal ini, synchronization primitives adalah metode yang perlu diimplementasikan dalam sebuah sistem operasi. Synchronization primitives yaitu sebutan untuk metode yang dapat menjamin seluruh task dalam sistem multitasking agar dapat berjalan secara sinkron dalam pengaksesan sebuah resource.
 
void putchar(int chr){
   ...
}

void print(char * str){
   while (* str){
      putchar(*str);
      str++;
   }
}

Kode di atas adalah contoh sederhana, dimana programmer harus mulai mempertimbangkan untuk mengimplementasikansynchronization primitive. Bayangkan jika dua task mengakses print() secara hampir bersamaan dalam sistem multitasking. Belum sempat salah satu task mencetak satu per satu karakter dari string, tiba-tiba terjadi task switch ke task lain yang juga ingin menggunakan fungsi print().

task 1:
print (“hello”);
task 2:
print (“world”);

Tanpa sinkronisasi, bisa jadi yang akan tampil di layar terlihat kacau. Misalnya saja, apabila setiap baru saja mencetak sebuah karakter, terburu terjadi task switch, mungkin akan tampil seperti ini.

hweolrllod

Spinlock adalah salah satu metode sinkronisasi dengan menerapkan lock. Contohnya pada fungsi print() yang sudah dimodifikasi di bawah ini. Selama fungsi print() diakses oleh salah satu task, print_lock akan tetap bernilai 1. Task lain yang perlu mengakses print() wajib menunggu hingga task sebelumnya menyelesaikan print dan mengembalikan print_lock sehingga bernilai 0.

char print_lock;
void print(char * str){
   acquire_spinlock(&print_lock);
   while (* str){
      putchar(*str);
      str++;
   }
   release_spinlock(&print_lock);
}

Task yang lebih dahulu memanggil print() akan memanggilacquire_spinlock(). Fungsi ini akan meng-set variabel print_lock = 1 apabila print_lock masih bernilai 0, lalu segera melanjutkan eksekusi. Task lain yang berjalan bersamaan namun sedikit tertinggal, akan mengalami peristiwa busy-waiting ketika memanggil acquire_spinlock(), karena print_lock masih di-set bernilai 1 oleh task sebelumnya. Busy-waiting akan terus berlangsung hingga task sebelumnya memanggil release_spinlock(), sehingga meng-set print_lock = 0.

Algoritma
Acquire Spinlock:
1. Tunggu hingga lock bernilai 0.
2. Jika lock sudah 0, set lock = 1.

Release Spinlock:
1. Set lock = 0.

Implementasi
Sederhananya, acquire_spinlock() bisa saja ditulis dengan kode C semacam ini:
void acquire_spinlock(char * lock ){
   while (* lock != 0){
      //do nothing
      //busy-waiting
   }
   * lock = 1;
}

Akan tetapi, dalam dunia nyata, kode di atas jauh kurang efektif. Apalagi dalam keadaan thread yang cukup padat. Ini karena jika diuraikan, kode while() akan diterjemahkan compiler menjadi serangkaian instruksi assembly yang rumit.

tes:
cmp BYTE PTR [print_lock], 0
jne tes
mov BYTE PTR [print_lock], 1

Misalnya, katakanlah terdapat 3 task yang sama-sama melakukan acquire. Task 1 baru saja melepas print_lock. Sayangnya, setelah itu task 2 dan task 3 secara bersamaan baru saja selesai melakukan instruksi CMP yang memberikan sinyal bahwa print_lock sudah terlepas, namun sama-sama pula terjadi task switch sebelum menjalankan instruksi JNE. Akhirnya, task 2 dan task 3 lolos dari lock lalu mengakses fungsi print() secara bersamaan.
Kondisi seperti itu dapat dihindari dengan memanfaatkan atomic operation, yaitu dengan memanfaatkan instruksi assembly yang dapat melakukan acquire tanpa harus melakukan instruksi pembandingan (CMP) ataupun testing terlebih dahulu. Dalam arsitektur intel, ini bisa dilakukan dengan instruksi XCHG yang diinputkan melalui inline assembly.

tes:
mov al, 1
xchg BYTE PTR [print_lock], al
cmp al,1
je tes

Selama XCHG menghasilkan nilai 1, sudah diketahui bahwa print_lock masih dikuasai task lain, namun jika 0, artinya task sudah berhasil mengambil alih lock. Meskipun terjadi task switch antar banyak task, semuanya tidak akan dapat melewati taktik XCHG.

inline unsigned char _atomic_xchg8(unsigned char* lock, unsigned char x ){
   asm volatile("xchg %1, %0":"=r" (x):"m"(*(volatile unsigned char *)lock),"0" (x):"memory");
   return x;
}

inline void acquire_spinlock(unsigned char *lock){
   while ( 1){
      if ( _atomic_xchg8(lock, 1)== 0) return ;
      while (* lock != 0){
         asm("pause");
      }
   }
}

inline void release_spinlock(unsigned char *lock){
   * lock = 0;
}

Read more

Apa Itu Device Context (Windows) ?

Device context adalah sebuah objek struktur data internal Windows yang banyak digunakan untuk menangani objek grafis. Semua yang tampak pada desktop semuanya terdiri atas kumpulan representatif dari device context.

Device Context, atau sering pula ditulis singkat sebagai DC merupakan objek yang bertanggung jawab mendeskripsikan elemen grafis di sistem Windows kita. Meskipun setiap unit warna dalam desktop terdiri atas piksel, kebanyakan sistem lebih suka memilih metode lain untuk menyimpan gambar tersebut. Alasannya, adalah karena ada banyak objek yang harus disimpan dalam RAM yang berkapasitas terbatas. Inilah mengapa device context ada. Jika sudah paham tentang perbedaan grafis bitmap dan vektor, maka grafis vektor ini adalah yang lebih banyak merepresentasikan tentang bagaimana si device context ini bekerja.

Sebagian besar elemen dasar di desktop umumnya disusun atas bidang-bidang sederhana yang tidak jauh dari garis, persegi atau lingkaran. Sebuah objek device context bisa diibaratkan sebagai resep. Yaitu sebuah resep untuk menciptakan sebuah objek gambar. Dalam resep tersebut terdapat deskripsi setiap detail partikel objek yang akan menyusun gambar seara utuh, berikut warna, atribut dan urutan gambar objek.

Cara ini lebih efektif daripada mendeskripsikan sebuah bidang yang terdiri atas piksel-piksel. Bayangkan, sebuah persegi 100 x 100 berkedalaman 32bpp saja dapat memakan memori 100 x 100 x 4 = 40.000 (40 KB). Dengan banyaknya aplikasi dan komponen GUI, menyimpan data secara eksplisit dengan piksel akan kurang efisien. Device context menjawab tantangan ini dengan menyediakan objek struktur data yang mendeskripsikan bidang yang ingin digambar.

Untuk menyimpan bentuk dan ukuran persegi yang sama, sebuah DC hanya butuh data beberapa byte untuk mendeskripsikan bidang tersebut, misalnya jenis objek, atribut panjang dan lebar, serta warna dari objek.

Contoh lainnya, apabila sebuah DC menyimpan objek grafis seperti di atas, maka di dalam objek DC tersebut akan terdapat data yang harus mendeskripsikan proses gambar elemen dengan benar:
1. Buat kanvas persegi x * y background putih
2. Gambar lingkaran di x dan y dengan ukuran w dan h, border n piksel hitam dan background kuning.
3. Buat 4 lingkaran (untuk mata) ...
4. Buat arc (untuk mulut) ...

Nah, sekarang sudah ada gambaran kan? Kira-kira seperti itulah DC. Kalau saja Windows itu open source, mungkin source codenya akan dijelaskan sekalian. Berhubung tidak demikian, mengkin sedikit tulisan ini akan memberikan gambaran mengenai DC tersebut.

Read more

Contoh Dynamic Memory Allocation Dengan Doubly-linked List, First-fit & Auto Left-Right Join [Part 4]

Bagian terakhir ini akan membahas tentang pembebasan memori ( Free() ). Fungsi free() sejatinya hanya mengubah field state kembali ke 0. Tapi karena tanggung jawabnya, alokator harus mengurus masalah fragmentasi internal. Ia harus memeriksa field bebas lain di sebelah kiri dan kanan chunk yang sedang dibebaskan. Apabila bebas, salah satu atau keduanya harus segera digabungkan.

int Free(void *addr){
HCHUNK *c,*p,*n;
c = (HCHUNK*)((ulong)addr - sizeof(HCHUNK));
if(c->magic != CMAGIC) return ­1;
if(c->state == 0) return ­2;
c->state = 0;
p = c->prev;
n = c->next;
if(n){
if(n->state == 0){
c->size += sizeof(HCHUNK) + n->size;
c->next = n->next;
if(n->next) n->next->prev = c;
}
}

if(p){
if(p->state == 0){
p->size += sizeof(HCHUNK) + c->size;
p->next = c->next;
if(c->next) c->next->prev = p;
}
}
return 0;
}

Proses pembebasan dan penggabungan dibantu dengan 3 buah variabel pointer

HCHUNK.
HCHUNK *c,*p,*n;

c merujuk pada HCHUNK dari alamat chunk yang sedang dibebaskan; p dan n merujuk ke chunk sebelah kiri (previous) dan kanan (next) dari chunk yang sedang dibebaskan.

Argumen addr dari fungsi ini berupa pointer chunk yang telah dialokasikan oleh Malloc() sebelumnya. Untuk mengetahui HCHUNK dari alamat tersebut, kurangi alamat addr dengan ukuran struktur HCHUNK.

c = (HCHUNK*)((ulong)addr - sizeof(HCHUNK));

Pastikan alamat chunk dari argumen addr adalah benar. Jika salah, dapat dipastikan nilai magic dari HCHUNK tidak akan bernilai valid. Jika jelas validitasnya, lanjut periksa juga field state. Jangan sampai kita menyiakan waktu untuk membebaskan chunk yang sudah bebas (state == 0).

if(c->magic != CMAGIC) return ­1;
if(c->state == 0) return ­2;

Cukup sudah. Sekarang bebaskan chunk ini.

c->state = 0;

2 langkah terakhir adalah prosedur penggabungan. Ambil pointer kedua chunk sampingnya dari field prev dan next.

p = c->prev;
n = c->next;

Mulai penggabungan dari chunk sebelah kanan. Dan lanjutkan dengan chunk sebelah kiri.

if(n){
if(n->state == 0){
c->size += sizeof(HCHUNK) + n->size;
c->next = n->next;
if(n->next) n->next->prev = c;
}
}
if(p){
if(p->state == 0){
p->size += sizeof(HCHUNK) + c->size;
p->next = c->next;
if(c->next) c->next->prev = p;
}
}

Nilai n dapat bernilai 0 apabila chunk yang baru saja dibebaskan adalah chunk terakhir. Jadi sebelum memeriksa state dari chunk n, pastikan dulu n bukan 0. Penggabungan dilakukan dengan 2 tahapan; update ukuran chunk pada field size chunk c dengan menambahkannya ukuran dari chunk n. Karena HCHUNK untuk n tidak terpakai lagi, kita juga menambahkan ukuran sejumlah ukuran struktur HCHUNK ( sizeof(HCHUNK) ) pada ukuran chunk c yang baru; kedua, update field next dari c, sehingga link antar chunk akan menjadi seperti di bawah ini.

Lakukan juga hal sama pada p dengan cara seperti sebelumnya.

Debugging
Untuk keperluan pengecekan, saya sudah buatkan fungsi dumper sederhana untuk mencetak properti semua chunk dalam HMALLOC. Kode ini self-explained, ya.

void HMallocDump(HMALLOC *h){
HCHUNK *c = h->first;
printf("HMALLOC Dump:\n");
while(c){
printf("HCHUNK size 0x%x state %x at 0x%x \
   prev 0x%x next 0x%x\n",
c->size,c->state,c, c->prev,c->next);
c = c->next;
}
}


Contoh Hasil
Hasil berikut adalah contoh implementasi Malloc() di kernel JauraOS.
https://github.com/irvanherz/jaura

Read more

Contoh Dynamic Memory Allocation Dengan Doubly-linked List, First-fit & Auto Left-Right Join [Part 3]

Bagian ini akan khusus membahas tentan proses alokasi ( Malloc() ). Sistematika kerja alokator dalam mengalokasikan memori sudah diketahui dari gambar ilustrasi yang kita lihat sebelumnya. Pada prakteknya, ada sedikit penjabaran yang harus diperhatikan. Alokator melakukan alokasi dari fungsi Malloc() yang kita buat. Pencarian mulai dilakukan dari melihat HCHUNK pertama yang ditunjukkan oleh field first pada HMALLOC dan mengikuti pointer next pada HCHUNK hingga ditemukan hasil. Apabila tidak ada chunk bebas yang memiliki ukuran cukup, fungsi harus mengembalikan 0.

for(HCHUNK *c = m­->first; c != 0; c = c-­>next){
//Check chunk (*c)
}
return 0;

Setiap chunk yang diperiksa melewati beberapa urutan tahap uji sebagai berikut.
1. Jika chunk→magic salah, gagalkan fungsi
2. Jika chunk→state = 1 (allocated), lewati dan lanjutkan memeriksa chunk berikutnya(chunk→next).
3. Jika chunk→size < size yang diminta (not enough), lanjutkan memeriksa chunk berikutnya(chunk→next).
4. Jika chunk→size == size dan chunk→size <= size + sizeof(HCHUNK) (size was fit), langsung alokasikan chunk ini sebagai hasil. Kondisi “chunk→size <= size + ukuran HCHUNK” harus diperiksa, karena jika chunk bebas melebihi yang diminta, kita hanya boleh mengambil sebagian chunk yang cukup, sisanya harus dibuat chunk yang baru (dibuat pada kondisi 5). Sebelum memutuskan buat yang baru, kondisi ini diperiksa untuk memastikan apakah sisa chunk cukup untuk menyimpan header HCHUNK dan minimum chunk sebesar 1 byte. Jika tidak, sebaiknya kita ikutkan saja sisanya sebagai hasil.
5. Apabila tidak masuk kondisi 3 auatupun 4, artinya chunk terlalu besar (size bigger), alokator harus melakukan pemecahan chunk menjadi 2 bagian. Satu bagian sebagai hasil alokasi dan sisanya dibuat untuk dibiarkan dalam kondisi bebas.

void *Malloc(HMALLOC *m,uint size){
for(HCHUNK *c = m-­>first; c != 0; c = c-­>next){
if(c­->magic != CMAGIC){
printf("FATAL:Broken malloc!\n");
return 0;
}
if(c-­>state == 1) continue;
else if(c-­>size < size) continue;
else if((c-­>size >= size) &&
  (c­->size <= size + sizeof(HCHUNK))) {
c-­>state = 1;
return (void*)((ulong)c + sizeof(HCHUNK));
}
else {
HCHUNK *newc;
newc = (HCHUNK*)((ulong)c + sizeof(HCHUNK) + size);
newc­->magic = CMAGIC;
newc­->state = 0;
newc­->size = c­->size - size - sizeof(HCHUNK);
newc­->prev = c;
newc­->next = c-­>next;
c­->next = newc;
c­->size = size;
c­->state = 1;
return (void*)((ulong)c + sizeof(HCHUNK));
}
}
return 0;
}

Periksa kondisi 1
if(c­->magic != CMAGIC){
printf("FATAL:Broken malloc!\n");
return 0;
}

Periksa kondisi 2
if(c-­>state == 1) continue;

Periksa kondisi 3
else if(c­->size < size) continue;

Periksa kondisi 4
else if((c->size >= size) && (c->size <= size + sizeof(HCHUNK))) {
c->state = 1;
return (void*)((ulong)c + sizeof(HCHUNK));
}

Kondisi 5
else {
HCHUNK *newc;
newc = (HCHUNK*)((ulong)c + sizeof(HCHUNK) + size);
newc-­>magic = CMAGIC;
newc­->state = 0;
newc­->size = c->size - size - sizeof(HCHUNK);
newc­->prev = c;
newc­->next = c->next;
c­->next = newc;
c­->size = size;
c-­>state = 1;
return (void*)((ulong)c + sizeof(HCHUNK));
}

Kondisi 5 adalah kondisi yang sedikit membutuhkan logika. Sederhananya, proses untuk menangi kondisi 5 sesuai dengan ilustrasi di bawah ini. Sederhana memang, namun yang sedikit membingungkan adalah mengatur prev dan next agar tetap terhubung satu sama lain.

Sebelum terpecah

Sesudah terpecah

Read more

Contoh Dynamic Memory Allocation Dengan Doubly-linked List, First-fit & Auto Left-Right Join [Part 2]

Penerapan alokator akan membutuhkan 2 struktur data untuk mentracking seluruh aktivitas alokasi. Struktur yang pertama adalah header HMALLOC. Di dalamnya, terdapat informasi mengenai ukuran dari seluruh blok memori yang tersedia dan potongan chunk memori pertama yang berada dalam blok tersebut. Penempatan HMALLOC akan selalu dilakukan di bagian paling awal dari blok, sebelum deretan chunk beserta headernya. Ukuran blok total dan kapasitas maksimum dari chunk itu sendiri akan kita tentukan saat inisialisasi.

Berikut adalah wujud struktur HMALLOC yang ditulis dalam C.

typedef struct _HMALLOC{
uint size;
HCHUNK *first;
}HMALLOC;

Sementara itu, struktur header yang akan selalu terpasang pada setiap awal chunk akan kita sebut sebagai HCHUNK. Struktur ini mendeskripsikan informasi pokok dari chunk yang diwakilinya.

typedef struct _HCHUNK {
int magic;
uint size;
char state;
struct _HCHUNK *prev,*next;
} HCHUNK;

Bagian unik dari HCHUNK adalah field magic. Nilainya akan selalu sama bagi setiap struktur HCHUNK. Kita akan membuat nilainya seunik mungkin. Nilai ini akan kita didefinisakan sebagai CMAGIC.

#define CMAGIC 0xBEDABEDA

Ketika program mengalami kesalahan saat mengakses blok lain, header dapat ter-overwrite, sehingga tak valid lagi. Jika dibiarkan, alokator justru akan berpotensi merusak sistem. Untuk itu, alokator akan menggagalkan alokasi memori saat ditemukan nilai magic yang salah. Saat program gagal mengalokasikan memori, program biasanya akan selalu memeriksa hasil alokasi dan membuat notifikasi ke user apabila terjadi kegagalan, jadi jangan kawatir.

Selanjutnya, field size adalah ukuran dari chunk memori yang diwakili oleh header. Ingat, hanya ukuran chunk saja, tanpa ukuran header. Lalu, field state bertugas memberitahu alokator, apakah field yang diwakili HCHUNK masih bebas atau sudah teralokasi. Nilainya 0 akan dianggap bebas, atau BUKAN 0 apabila teralokasi. Terakhir, field prev dan next adalah 2 buah pointer doubly-linked list yang akan mengarahkan ke struktur HCHUNK disampingnya. Alokator akan menelusuri pointer ini untuk mencari chunk memori yang dapat dialokasikan.

Inisialisasi
Persiapan dilakukan dengan mengatur nilai HMALLOC di dalam blok. Awalnya, sistem harus menyediakan blok memori untuk keperluan alokasi. Fungsi MallocInit() berikut akan memproses blok dari parameter alamat addr dan ukuran size yang diberikan.

HMALLOC *MallocInit(void *addr, uint size){

HMALLOC *m;

if(size <= sizeof(HMALLOC) + sizeof(HCHUNK))

return 0;

m = (HMALLOC *) addr;

m->first = (HCHUNK*) ((ulong)addr + sizeof(HMALLOC));

m->size = size;

m->first->magic = CMAGIC;

m->first->state = 0;

m->first->size = size - sizeof(HMALLOC) - sizeof(HCHUNK);

m->first->prev = m->first->next = 0;

return m;

}

Pertama, periksa apakah blok yang diberikan sudah cukup untuk menyimpan sebuah HMALLOC dan chunk awal sebesar minimal 1 byte, jangan lupa beserta header HCHUNKnya. Jika tidak, fungsi ini harus mengembalikan error.

if(size <= sizeof(HMALLOC) + sizeof(HCHUNK))

return 0;

Letakkan HMALLOC di bagian paling depan dari blok. Lengkapi juga isi tiap fieldnya. Setelah itu chunk pertama (m->first) juga akan dibuat tepat setelah header HMALLOC.

m = (HMALLOC *) addr;

m->first = (HCHUNK*) ((ulong)addr + sizeof(HMALLOC));

m->size = size;

Lalu atur semua nilai field dari HCHUNK untuk chunk pertama. Tentu saja, chunk ini harus dalam keadaan bebas(state = 0). Ukuran chunk akhirnya diketahui dari ukuran argumen size yang dikurangi dengan ukuran header HMALLOC dan ukuran header HCHUNK pertama.

m->first->magic = CMAGIC;

m->first->state = 0;

m->first->size = size - sizeof(HMALLOC) – sizeof(HCHUNK);

Masih HCHUNK pertama kali, jadi, biarkan field next dan prev kosong dulu.

m->first->prev = m->first->next = 0;

Terakhir, kembalikan pointer ke struktur HMALLOC valid yang sudah dibuat. Karena HMALLOC berada di awal blok, alamat HMALLOC yang berhasil dibuat bisa dipastikan == argumen addr. Nantinya, pointer ini akan dijadikan parameter saat alokasi, sehingga alokator tahu, blok mana yang harus diproses dan dimana ia harus menemukan chunk-chunk nya.

return m;

Read more