SCRIPT C UNTUK BACA CPU

Berikut script C untuk melihat properti CPU, RAM, dan VGA di Linux. Karena informasi hardware berada di berbagai lokasi di sistem Linux, script ini membaca dari beberapa sumber:

Script Lengkap: hardware_info.c

```c

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/sysinfo.h>

#include <dirent.h>

// Fungsi untuk membaca file teks

char* read_file(const char* filename) {

    FILE* file = fopen(filename, "r");

    if (!file) {

        return NULL;

    }

    

    fseek(file, 0, SEEK_END);

    long length = ftell(file);

    fseek(file, 0, SEEK_SET);

    

    char* buffer = malloc(length + 1);

    if (buffer) {

        fread(buffer, 1, length, file);

        buffer[length] = '\0';

    }

    

    fclose(file);

    return buffer;

}

// Fungsi untuk membaca satu baris dari file

void read_single_line(const char* filename, char* buffer, size_t size) {

    FILE* file = fopen(filename, "r");

    if (file) {

        if (fgets(buffer, size, file)) {

            // Hapus newline di akhir

            buffer[strcspn(buffer, "\n")] = 0;

        }

        fclose(file);

    } else {

        strncpy(buffer, "Tidak tersedia", size);

    }

}

// Fungsi untuk menampilkan informasi CPU

void display_cpu_info() {

    printf("=== INFORMASI CPU ===\n");

    

    // Baca /proc/cpuinfo

    char* cpuinfo = read_file("/proc/cpuinfo");

    if (cpuinfo) {

        char* model = strstr(cpuinfo, "model name");

        if (model) {

            model = strchr(model, ':');

            if (model) {

                model += 2; // Lewati ": "

                char* end = strchr(model, '\n');

                if (end) *end = '\0';

                printf("Model CPU     : %s\n", model);

            }

        }

        

        // Hitung jumlah core

        int cores = 0;

        char* token = cpuinfo;

        while ((token = strstr(token, "processor")) != NULL) {

            cores++;

            token += 9;

        }

        printf("Jumlah Core   : %d\n", cores);

        

        // Frekuensi CPU

        char freq[100];

        read_single_line("/sys/devices/system/cpu/cpu0/cpufreq/scaling_max_freq", freq, sizeof(freq));

        if (strcmp(freq, "Tidak tersedia") != 0) {

            float freq_ghz = atof(freq) / 1000000.0;

            printf("Frekuensi Max : %.2f GHz\n", freq_ghz);

        }

        

        free(cpuinfo);

    }

    

    // Architecture

    char arch[100];

    read_single_line("/proc/sys/kernel/arch", arch, sizeof(arch));

    printf("Arsitektur    : %s\n", arch);

    printf("\n");

}

// Fungsi untuk menampilkan informasi RAM

void display_ram_info() {

    printf("=== INFORMASI MEMORI (RAM) ===\n");

    

    struct sysinfo sys_info;

    if (sysinfo(&sys_info) == 0) {

        // Konversi ke GB

        double total_ram = (double)sys_info.totalram * sys_info.mem_unit / (1024 * 1024 * 1024);

        double free_ram = (double)sys_info.freeram * sys_info.mem_unit / (1024 * 1024 * 1024);

        double used_ram = total_ram - free_ram;

        double percent_used = (used_ram / total_ram) * 100;

        

        printf("Total RAM     : %.2f GB\n", total_ram);

        printf("Digunakan     : %.2f GB (%.1f%%)\n", used_ram, percent_used);

        printf("Tersedia      : %.2f GB\n", free_ram);

        printf("Swap Total    : %.2f GB\n", 

               (double)sys_info.totalswap * sys_info.mem_unit / (1024 * 1024 * 1024));

    } else {

        printf("Error membaca informasi RAM\n");

    }

    printf("\n");

}

// Fungsi untuk menampilkan informasi VGA/GPU

void display_gpu_info() {

    printf("=== INFORMASI VGA/GPU ===\n");

    

    int gpu_count = 0;

    

    // Coba deteksi melalui PCI (direktori /sys/class/drm/)

    DIR* dir = opendir("/sys/class/drm/");

    if (dir) {

        struct dirent* entry;

        while ((entry = readdir(dir)) != NULL) {

            // Cari entry yang seperti cardX (misal: card0)

            if (strncmp(entry->d_name, "card", 4) == 0 && isdigit(entry->d_name[4])) {

                char path[256];

                snprintf(path, sizeof(path), "/sys/class/drm/%s/device/vendor", entry->d_name);

                

                char vendor_id[100];

                read_single_line(path, vendor_id, sizeof(vendor_id));

                

                // Hanya tampilkan jika bukan vendor 0xffff (virtual)

                if (strcmp(vendor_id, "0xffff") != 0) {

                    gpu_count++;

                    

                    printf("\nGPU %d:\n", gpu_count);

                    

                    // Nama device

                    snprintf(path, sizeof(path), "/sys/class/drm/%s/device/device", entry->d_name);

                    char device_id[100];

                    read_single_line(path, device_id, sizeof(device_id));

                    

                    // Vendor berdasarkan ID

                    if (strstr(vendor_id, "0x8086") || strcmp(vendor_id, "8086") == 0) {

                        printf("  Vendor      : Intel\n");

                    } else if (strstr(vendor_id, "0x10de") || strcmp(vendor_id, "10de") == 0) {

                        printf("  Vendor      : NVIDIA\n");

                    } else if (strstr(vendor_id, "0x1002") || strcmp(vendor_id, "1002") == 0) {

                        printf("  Vendor      : AMD/ATI\n");

                    } else {

                        printf("  Vendor ID   : %s\n", vendor_id);

                    }

                    

                    printf("  Device ID   : %s\n", device_id);

                    

                    // Baca driver yang digunakan

                    snprintf(path, sizeof(path), "/sys/class/drm/%s/device/uevent", entry->d_name);

                    char* uevent = read_file(path);

                    if (uevent) {

                        char* driver = strstr(uevent, "DRIVER=");

                        if (driver) {

                            driver += 7; // Lewati "DRIVER="

                            char* end = strchr(driver, '\n');

                            if (end) *end = '\0';

                            printf("  Driver      : %s\n", driver);

                        }

                        free(uevent);

                    }

                    

                    // Baca model dari modalias

                    snprintf(path, sizeof(path), "/sys/class/drm/%s/device/modalias", entry->d_name);

                    char modalias[256];

                    read_single_line(path, modalias, sizeof(modalias));

                    

                    // Ekstrak nama model dari modalias

                    char* model_start = strstr(modalias, "v0000");

                    if (model_start) {

                        char model[100];

                        sscanf(model_start, "v%*[0-9A-F]d%*[0-9A-F]%*[^&]&%[^&]", model);

                        if (strlen(model) > 0) {

                            printf("  Model       : %s\n", model);

                        }

                    }

                }

            }

        }

        closedir(dir);

    }

    

    // Alternatif: coba lspci melalui popen

    if (gpu_count == 0) {

        printf("Mencoba deteksi via lspci...\n");

        

        FILE* lspci = popen("lspci | grep -i vga", "r");

        if (lspci) {

            char line[256];

            while (fgets(line, sizeof(line), lspci)) {

                // Hapus newline

                line[strcspn(line, "\n")] = 0;

                

                // Ekstrak nama GPU

                char* colon = strchr(line, ':');

                if (colon) {

                    printf("  %s\n", colon + 2);

                    gpu_count++;

                }

            }

            pclose(lspci);

        }

    }

    

    if (gpu_count == 0) {

        printf("Tidak ditemukan informasi GPU\n");

    }

    printf("\n");

}

// Fungsi untuk menampilkan informasi sistem

void display_system_info() {

    printf("=== INFORMASI SISTEM ===\n");

    

    // Nama host

    char hostname[100];

    if (gethostname(hostname, sizeof(hostname)) == 0) {

        printf("Hostname      : %s\n", hostname);

    }

    

    // Kernel version

    char kernel_version[100];

    read_single_line("/proc/sys/kernel/osrelease", kernel_version, sizeof(kernel_version));

    printf("Kernel        : %s\n", kernel_version);

    

    // Uptime

    FILE* uptime_file = fopen("/proc/uptime", "r");

    if (uptime_file) {

        double uptime_seconds;

        fscanf(uptime_file, "%lf", &uptime_seconds);

        fclose(uptime_file);

        

        int days = uptime_seconds / 86400;

        int hours = (uptime_seconds - (days * 86400)) / 3600;

        int minutes = (uptime_seconds - (days * 86400) - (hours * 3600)) / 60;

        

        printf("Uptime        : %d hari, %d jam, %d menit\n", days, hours, minutes);

    }

    

    printf("\n");

}

int main() {

    printf("========================================\n");

    printf("    SYSTEM HARDWARE INFORMATION\n");

    printf("========================================\n\n");

    

    // Tampilkan semua informasi

    display_system_info();

    display_cpu_info();

    display_ram_info();

    display_gpu_info();

    

    printf("========================================\n");

    printf("Informasi diambil dari: /proc, /sys, sysinfo()\n");

    printf("========================================\n");

    

    return 0;

}

```

Versi Sederhana (Minimalis)

```c

#include <stdio.h>

#include <stdlib.h>

#include <sys/sysinfo.h>

void simple_hardware_info() {

    printf("=== INFORMASI HARDWARE SEDERHANA ===\n\n");

    

    // 1. CPU Info

    printf("CPU:\n");

    FILE* cpuinfo = fopen("/proc/cpuinfo", "r");

    if (cpuinfo) {

        char line[256];

        int cores = 0;

        while (fgets(line, sizeof(line), cpuinfo)) {

            if (strstr(line, "model name")) {

                printf("  Model: %s", strchr(line, ':') + 2);

            }

            if (strstr(line, "processor")) {

                cores++;

            }

        }

        printf("  Cores: %d\n", cores);

        fclose(cpuinfo);

    }

    

    // 2. RAM Info

    printf("\nRAM:\n");

    struct sysinfo info;

    if (sysinfo(&info) == 0) {

        double total_gb = (double)info.totalram * info.mem_unit / (1024*1024*1024);

        double free_gb = (double)info.freeram * info.mem_unit / (1024*1024*1024);

        printf("  Total: %.2f GB\n", total_gb);

        printf("  Free : %.2f GB\n", free_gb);

        printf("  Used : %.2f GB\n", total_gb - free_gb);

    }

    

    // 3. GPU Info (simple)

    printf("\nGPU:\n");

    FILE* lspci = popen("lspci | grep -i vga", "r");

    if (lspci) {

        char gpu_info[256];

        if (fgets(gpu_info, sizeof(gpu_info), lspci)) {

            printf("  %s", gpu_info);

        } else {

            printf("  Tidak terdeteksi\n");

        }

        pclose(lspci);

    }

}

int main() {

    simple_hardware_info();

    return 0;

}

```

Cara Kompilasi dan Menjalankan

```bash

# Kompilasi script lengkap

gcc -o hardware_info hardware_info.c

# Jalankan dengan hak akses root untuk info lengkap

sudo ./hardware_info

# Atau kompilasi versi sederhana

gcc -o simple_hw simple_version.c

./simple_hw

```

Penjelasan Singkat:

1. Informasi CPU:

   · Dibaca dari /proc/cpuinfo

   · Menampilkan model, jumlah core, dan frekuensi

2. Informasi RAM:

   · Menggunakan sysinfo() dari <sys/sysinfo.h>

   · Menghitung total, used, dan free memory

3. Informasi VGA/GPU:

   · Melihat direktori /sys/class/drm/ untuk kartu grafis

   · Alternatif menggunakan perintah lspci

   · Mendeteksi vendor (NVIDIA, AMD, Intel)

4. Tambahan:

   · Informasi sistem (hostname, kernel, uptime)

   · Error handling sederhana

Catatan Penting:

· Script memerlukan hak akses root untuk membaca beberapa file sistem

· Informasi VGA mungkin tidak lengkap tanpa driver yang terpasang

· Untuk sistem embedded atau minimal, beberapa path mungkin tidak tersedia

· Kompilasi dengan: gcc -o hwinfo hwinfo.c

Script ini memberikan gambaran umum tentang hardware system. Untuk informasi yang lebih detail, tools seperti lshw, dmidecode, atau nvidia-smi (untuk NVIDIA) lebih direkomendasikan.

Read more »

MINI OS MINDSET

Mantap. Ini titik transisi dari “belajar C” → “berpikir seperti pembuat OS”.
Saya tidak akan langsung lompat ke kernel coding (itu jebakan), tapi membentuk mindset OS dulu lewat eksperimen user-space yang rasanya seperti OS.

Mini OS mindset = memahami fungsi OS dengan menirunya dari C

---

🧠 APA ITU “OS MINDSET”?

OS bukan GUI, bukan installer, bukan distro.

OS itu menjawab 6 pertanyaan inti:

1. Siapa yang pakai CPU sekarang?
2. Siapa yang boleh pakai RAM?
3. Siapa yang boleh akses hardware?
4. Bagaimana program lahir & mati?
5. Bagaimana program saling bicara?
6. Bagaimana sistem tetap stabil saat ada error?

👉 Kita akan “meniru” ini tanpa menulis kernel dulu.

---

🧱 BLOK 1 — CPU & PROSES

🧪 Eksperimen: Anda jadi “scheduler”

#include <stdio.h>
#include <unistd.h>

int main() {
    for (int i = 0; i < 3; i++) {
        if (fork() == 0) {
            while (1) {
                printf("Proses %d jalan\n", i);
                sleep(1);
            }
        }
    }
    while (1);
}

🔍 Mindset OS:

• OS tidak menjalankan program
• OS mengatur giliran CPU
• Semua proses ingin hidup selamanya

💡 Inilah alasan scheduler ada.

---

🧱 BLOK 2 — MEMORI (KENAPA PROGRAM TIDAK BOLEH SEMBARANG)

🧪 Eksperimen: satu salah, semua mati

#include <stdlib.h>

int main() {
    int *p = malloc(4);
    free(p);
    *p = 10; // undefined behavior
}

🔍 Mindset OS:

• OS tidak percaya program
• OS harus melindungi dirinya
• Inilah alasan user space vs kernel space

💡 Tanpa proteksi memori → OS runtuh.

---

🧱 BLOK 3 — FILE = ABSTRAKSI PALING JENIUS

🧪 Eksperimen: semua adalah file

#include <stdio.h>

int main() {
    FILE *f = fopen("/proc/cpuinfo", "r");
    char buf[100];
    fgets(buf, 100, f);
    printf("%s", buf);
    fclose(f);
}

🔍 Mindset OS:

• CPU = file
• RAM = file
• Proses = file
• Device = file

💡 UNIX genius moment.

---

🧱 BLOK 4 — IPC (PROGRAM ITU TIDAK SENDIRIAN)

🧪 Eksperimen: proses ngobrol

#include <unistd.h>
#include <stdio.h>

int main() {
    int fd[2];
    pipe(fd);

    if (fork() == 0) {
        write(fd[1], "Halo", 4);
    } else {
        char buf[10];
        read(fd[0], buf, 4);
        printf("Diterima: %s\n", buf);
    }
}

🔍 Mindset OS:

• OS menghubungkan program
• Tanpa OS → program terisolasi total

---

🧱 BLOK 5 — ERROR ADALAH KENYATAAN

🧪 Eksperimen: OS tidak boleh panik

#include <stdio.h>
#include <fcntl.h>

int main() {
    int fd = open("tidak_ada.txt", O_RDONLY);
    if (fd < 0)
        perror("OS berkata");
}

🔍 Mindset OS:

• Error itu normal
• OS harus tenang dan konsisten
• Tidak boleh crash hanya karena user salah

---

🧱 BLOK 6 — KONTROL & BATASAN

🧪 Eksperimen: siapa berhak apa

#include <unistd.h>
#include <stdio.h>

int main() {
    printf("UID: %d\n", getuid());
}

🔍 Mindset OS:

• OS = polisi
• Permission bukan fitur tambahan
• Tapi fondasi keamanan

---

🧠 TRANSFORMASI MINDSET (INI PENTING)

Setelah tahap ini, Anda tidak lagi bertanya: ❌ “Bagaimana bikin program?”

Anda mulai bertanya: ✅ “Bagaimana sistem ini tetap stabil?” ✅ “Bagaimana mencegah user merusak sistem?” ✅ “Bagaimana mengisolasi kegagalan?”

👉 Ini OS thinking.

---

🚧 JEBATAN MENUJU “OS ASLI”

Kalau mindset ini sudah klik, baru lanjut ke:

1. Bootloader (tanpa BIOS)
2. Memory layout OS
3. Interrupt & IRQ
4. Scheduler sederhana
5. Syscall buatan sendiri

⚠️ Lompat ke kernel tanpa mindset ini = frustrasi

---

🔥 TANTANGAN MINI OS (OPSIONAL)

Tantangan 1 minggu

• Hari 1: Proses & fork
• Hari 2: File descriptor
• Hari 3: Memory & crash
• Hari 4: IPC
• Hari 5: Permission
• Hari 6: Mini shell
• Hari 7: Review OS design

---

🧭 Mau lanjut ke mana?

Saya bisa: 1️⃣ Bikin mini shell Linux step-by-step
2️⃣ Simulasikan kernel di user-space
3️⃣ Jelaskan transisi BIOS → kernel → user dengan C
4️⃣ Buat diagram OS mental model
5️⃣ Siapkan roadmap dari C → kernel dev

Tinggal bilang nomor berapa.

Read more »

Apa Yang Bisa Saya Lakukan dengan C?

Ini pertanyaan sangat sehat untuk orang yang benar-benar mau belajar C 👍
Saya jawab bukan dengan teori, tapi eksperimen nyata yang bisa Anda lakukan sekarang juga di Linux Mint, dan tiap eksperimen punya efek “wah” karena memperlihatkan apa yang tidak bisa dilakukan bahasa lain.

Saya susun dari paling aman → makin dekat ke mesin.

---

🔥 1️⃣ Lihat RAM “hidup” (Stack vs Heap)

Kesan: “Oh… variabel itu benar-benar punya alamat!”

#include <stdio.h>
#include <stdlib.h>

int main() {
    int a = 10;
    int *p = malloc(sizeof(int));
    *p = 20;

    printf("a (stack) = %d, alamat: %p\n", a, &a);
    printf("*p (heap) = %d, alamat: %p\n", *p, p);

    free(p);
    return 0;
}

Compile & run:

gcc ram.c -o ram
./ram

👉 Wah moment:
Anda melihat alamat RAM nyata, bukan konsep abstrak.

---

🔥 2️⃣ Program C mengintip memori sendiri

Kesan: “Program bisa membaca dirinya sendiri?!”

#include <stdio.h>

int main() {
    int x = 123;
    unsigned char *p = (unsigned char *)&x;

    for (int i = 0; i < sizeof(x); i++)
        printf("%02x ", p[i]);

    printf("\n");
}

👉 Anda melihat byte mentah dalam memori.

---

🔥 3️⃣ Program C bicara langsung ke OS (syscall)

Kesan: “Ini bukan printf, ini OS beneran!”

#include <unistd.h>

int main() {
    write(1, "Hello langsung ke kernel\n", 25);
    return 0;
}

Cek:

strace ./a.out

👉 Anda melihat system call ke kernel Linux.

---

🔥 4️⃣ Fork: satu program jadi dua

Kesan: “Program membelah diri!”

#include <stdio.h>
#include <unistd.h>

int main() {
    fork();
    printf("Saya hidup!\n");
    return 0;
}

👉 Satu source → dua proses OS.

---

🔥 5️⃣ Lihat proses Linux dari C (seperti ps)

Kesan: “C membaca sistem secara langsung”

#include <stdio.h>
#include <dirent.h>

int main() {
    DIR *d = opendir("/proc");
    struct dirent *dir;

    while ((dir = readdir(d)) != NULL) {
        if (dir->d_type == DT_DIR)
            printf("%s\n", dir->d_name);
    }

    closedir(d);
}

👉 /proc = jiwa Linux, dibaca pakai C.

---

🔥 6️⃣ Ukur kecepatan kode Anda sendiri

Kesan: “Oh… performa itu terasa!”

#include <stdio.h>
#include <time.h>

int main() {
    clock_t start = clock();
    for (long i = 0; i < 1000000000; i++);
    clock_t end = clock();

    printf("Waktu: %.2f detik\n",
           (double)(end - start) / CLOCKS_PER_SEC);
}

👉 Anda mulai merasakan biaya CPU.

---

🔥 7️⃣ Mini shell Linux (seperti bash kecil)

Kesan: “Saya bikin OS mini!”

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    char *cmd[] = {"ls", NULL};

    if (fork() == 0)
        execvp(cmd[0], cmd);
    else
        wait(NULL);

    return 0;
}

👉 Anda memanggil program lain seperti shell.

---

🔥 8️⃣ Bikin crash sengaja (dan paham kenapa)

Kesan: “Segmentation fault itu masuk akal!”

int main() {
    int *p = 0;
    *p = 10;
}

Run:

./a.out

👉 Sekarang Anda mengerti kesalahan fatal, bukan takut.

---

🔥 9️⃣ Lihat assembly hasil C Anda

Kesan: “C → mesin!”

gcc -S test.c

Buka file .s.

👉 Anda melihat bahasa CPU.

---

🔥 🔟 Mini roadmap “ketagihan C”

Jika Anda melakukan eksperimen 1–5 saja, biasanya muncul:

“Oh… ini yang bikin semua software bisa jalan.”

Lanjutkan dengan:

1. Pointer & memory layout
2. System call Linux
3. Process & thread
4. File descriptor
5. Networking dasar
6. Driver / kernel (teori)

---

🎯 Kenapa ini bikin kagum?

Karena C:

• Tidak menyembunyikan mesin
• Tidak menipu performa
• Tidak memanjakan

C mengajak Anda melihat realitas komputer

---

Kalau Anda mau, langkah berikutnya saya bisa:

• 📘 Buat challenge 7 hari belajar C
• 🧠 Jelaskan 1 konsep C per hari + eksperimen
• 🛠️ Bikin proyek kecil: mini-OS mindset
• ⚙️ Hubungkan eksperimen C ↔ BIOS ↔ kernel

Tinggal bilang mau lanjut ke yang mana.

Read more »