Initiated a new sample about unsafe coding

Author: buraksenyurt

Cargo.toml

@@ -28,4 +28,4 @@ members = [
     , "S23_asynchronous_programming"
     , "S24_file_io"
     , "S25_streams"
-]
+, "S26_unsafe_coding"]

README.md

@@ -37,6 +37,7 @@ bakabilirsiniz. Buradaki kodlar anlatımları desteklemek amacıyla kullanılır
 - [x] S23 - Asynchronous Programming
 - [x] S24 - File I/O Operations
 - [x] S25 - Stream Operations
+- [ ] S26 - Unsafe Zone
 
 ## Yardımcılar
 

S26_unsafe_coding/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "S26_unsafe_coding"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

S26_unsafe_coding/src/advanced.rs

@@ -0,0 +1,98 @@
+/*
+    Aynı türden nesneleri çok sık oluşturup(create) kaldırdığımız(drop) bir durum olduğunu ve bunu
+    kısıtlı bellek kapasitesine sahip bir gömülü sistem üzerinde işletmemiz gerektiğini düşünelim.
+    Böyle bir durumda kendi bellek havuzumu oluşturup yönetebiliriz ama bunun için unsafe alana
+    çıkmamız gerekir. Aşağıdaki kodlarda bu kullanima ait bir örnek yer alıyor.
+
+    Olası hataları ise şöyle ifade edebiliriz.
+
+    User After Free: Serbest kalan bellek bloğuna erişmeye çalışmak
+    Double Free : Aynı bellek bloğunu birden fazla kez serbest bırakılmaya çalışılması
+*/
+use std::alloc::{alloc, dealloc, Layout};
+use std::ptr;
+
+// const X64_ALIGN: usize = 8;
+
+/*
+   Sistemin 32 veya 64 bit olmasına göre gerekli olan byte hizalama değerini aldığımı fonksiyon
+*/
+fn get_alignment() -> usize {
+    if cfg!(target_pointer_width = "32") {
+        4 // 32-bit alignment
+    } else {
+        8 // 64-bit alignment
+    }
+}
+
+struct RapidMemoryPool {
+    total_size: usize,
+    usage: usize,
+    ref_pointer: *mut u8, //raw memory pointer
+}
+
+impl RapidMemoryPool {
+    fn new(total_size: usize) -> Self {
+        println!("Rapid Memory Pool initiating");
+
+        unsafe {
+            let layout = Layout::from_size_align(total_size, get_alignment()).unwrap();
+            println!("{layout:?}");
+            let ref_pointer = alloc(layout);
+            if ref_pointer.is_null() {
+                panic!("Could not allocate memory");
+            }
+            Self {
+                total_size,
+                usage: 0,
+                ref_pointer,
+            }
+        }
+    }
+
+    /*
+        Bu fonksiyon bir bellek bölgesini ayırır ve başlangıç adresini
+        raw pointer olarak döner. Buradaki raw pointer mutable'dır.
+    */
+    fn allocate(&mut self, amount: usize) -> *mut u8 {
+        unsafe {
+            if self.usage + amount > self.total_size {
+                panic!("Out of memory");
+            }
+            let alloc_ptr = self.ref_pointer.add(self.usage);
+            self.usage += amount;
+            alloc_ptr
+        }
+    }
+
+    fn free(&mut self) {
+        unsafe {
+            let layout = Layout::from_size_align(self.total_size, get_alignment()).unwrap();
+            dealloc(self.ref_pointer, layout);
+            self.ref_pointer = ptr::null_mut();
+            self.total_size = 0;
+            self.usage = 0;
+        }
+    }
+}
+
+impl Drop for RapidMemoryPool {
+    fn drop(&mut self) {
+        if !self.ref_pointer.is_null() {
+            self.free();
+            println!("Dropping memory pool");
+        }
+    }
+}
+
+pub fn run() {
+    let mut pool = RapidMemoryPool::new(1024);
+
+    unsafe {
+        let block_red = pool.allocate(256); // 256 byte yer ayırır
+        println!("Block Red allocated at: {:?}", block_red);
+
+        let block_blue = pool.allocate(512); // 512 byte yer ayırır
+        println!("Block Blue allocated at: {:?}", block_blue);
+    }
+} // Drop trait implementasyonu nedeniyle buradan bellek otomatik serbest kalır

S26_unsafe_coding/src/main.rs

@@ -0,0 +1,33 @@
+/*
+    Rust, bellek güvenliğini sağlama ve eşzamanlılık garantilerini sunmak üzere tasarlanmış bir
+    bellek yönetim sistemini benimser. Ancak bazı hallerde bu güvenli alanın dışına çıkılması
+    gerekebilir. Bu genellikle unsafe kod blokları ile gerçekleştirilir.
+
+    Unsafe bloklarda dilin standart güvnelik mekanizmaları göz ardı edilir. Unsafe kod tarafına
+    çıkmayı gerektiren durumlar kısaca şöyle özetlenebilir.
+
+    - Performans iyileştirmeleri: Rust'un kontrol mekanizmaları performans üzerinde yük oluşturabilir.
+    Mesela raw pointer'lar ile çalışmak çok hızlıdır. Bellek erişiminde bu hızlara çıkmak istediğimiz
+    durumlarda ele alabiliriz.
+    - C/C++ gibi rust dışındaki dillerle FFI(Foreign Function Interface) etkileşim kurmak istediğimiz
+    hallerde tercih edilir.
+    - Bellek bloklarını doğrudan manupile etmek istediğimiz hallerde.
+    - Rust'ın normal veri yapılarından daha büyük boyutlardaki (union yapılar gerektiren haller)
+    ihtiyaçlarda bit seviyesinde işlemler gerektiğinde
+    - Yazılan kodun mantıksal olarak güvenli olduğu hallerde kullanılan built-in fonksiyonellikleri
+    sağlayan api'ler için güvenlik kontrollerini atlamak istediğimizde
+
+    Unsafe kod kullanımında sorumluluk daha çok geliştiriciye kalır. Diğer yandan unsafe kod blokları
+    gerekli olduğu yerlerde kullanılır ve kalan kod parçaları rust'ın güvenlik kriterlerine tabi
+    olmaya devam eder.
+
+    Unsafe kodlama bellek güvenliği kriterlerinden feragat etmek anlamına gelse de, doğru şekilde
+    ve yerlerde kullanıldığında sistem seviyesinde kontrol ve yüksek performans sağlar.
+*/
+mod advanced;
+mod simple_ffi;
+
+fn main() {
+    // simple_ffi::run();
+    advanced::run();
+}

S26_unsafe_coding/src/simple_ffi.rs

@@ -0,0 +1,17 @@
+/*
+   Burada örnek bir FFI (Foreign Function Interface) kullanımı söz konusudur.
+   Bu kullanımlarda unsafe kod blokları ele alınır.
+   Örnekte Rust ortamından bir C fonksiyon çağrısı yapılır.
+*/
+extern "C" {
+    fn strlen(s: *const i8) -> usize;
+}
+
+pub fn run() {
+    let c_string = std::ffi::CString::new("Rust programming language with Ferris").unwrap();
+    let ptr = c_string.as_ptr();
+
+    unsafe {
+        println!("String length: {}", strlen(ptr));
+    }
+}