#!/bin/bash
# KVM仮想マシンの作成と管理
 
# 1. KVMが利用可能か確認
egrep -c '(vmx|svm)' /proc/cpuinfo
# → 0より大きければハードウェア仮想化対応
 
# 2. KVMモジュールのロード確認
lsmod | grep kvm
# kvm_intel   xxxxx  0
# kvm         xxxxx  1 kvm_intel
 
# 3. virt-installでVM作成
sudo virt-install \
  --name ubuntu-server \
  --ram 4096 \
  --vcpus 2 \
  --disk path=/var/lib/libvirt/images/ubuntu.qcow2,size=20,format=qcow2 \
  --os-variant ubuntu22.04 \
  --network bridge=virbr0 \
  --graphics none \
  --console pty,target_type=serial \
  --location 'http://archive.ubuntu.com/ubuntu/dists/jammy/main/installer-amd64/' \
  --extra-args 'console=ttyS0,115200n8 serial'
 
# 4. VM一覧の確認
virsh list --all
#  Id   Name            State
# ---   ----            -----
#  1    ubuntu-server   running
 
# 5. VMのリソース情報
virsh dominfo ubuntu-server
# Id:             1
# Name:           ubuntu-server
# UUID:           xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
# OS Type:        hvm
# State:          running
# CPU(s):         2
# Max memory:     4194304 KiB
# Used memory:    4194304 KiB
 
# 6. VMのCPUピンニング（NUMAアウェア配置）
virsh vcpupin ubuntu-server 0 2
virsh vcpupin ubuntu-server 1 3
# → vCPU 0をpCPU 2に、vCPU 1をpCPU 3に固定
 
# 7. ライブマイグレーション
virsh migrate --live ubuntu-server \
  qemu+ssh://destination-host/system \
  --verbose --persistent --undefinesource

#!/bin/bash
# コンテナの基盤: Linux 名前空間を手動で操作する
 
# === PID名前空間の分離 ===
# 新しいPID名前空間でbashを起動
sudo unshare --pid --fork --mount-proc bash -c '
  echo "=== 新しいPID名前空間 ==="
  echo "PID 1 は自分自身:"
  ps aux
  echo ""
  echo "ホストのプロセスは見えない"
'
 
# === ネットワーク名前空間の分離 ===
# 新しいネットワーク名前空間を作成
sudo ip netns add container-ns
 
# vethペアを作成（仮想イーサネットケーブル）
sudo ip link add veth-host type veth peer name veth-container
 
# コンテナ側のvethを名前空間に移動
sudo ip link add veth-host type veth peer name veth-container
sudo ip link set veth-container netns container-ns
 
# IPアドレスの設定
sudo ip addr add 10.0.0.1/24 dev veth-host
sudo ip link set veth-host up
 
sudo ip netns exec container-ns bash -c '
  ip addr add 10.0.0.2/24 dev veth-container
  ip link set veth-container up
  ip link set lo up
  echo "コンテナ内のネットワーク:"
  ip addr show
'
 
# 疎通確認
ping -c 3 10.0.0.2
 
# クリーンアップ
sudo ip netns del container-ns
 
# === cgroups v2 でリソース制限 ===
# cgroups v2 の確認
mount | grep cgroup2
# cgroup2 on /sys/fs/cgroup type cgroup2 (rw,nosuid,nodev,noexec,relatime)
 
# メモリ制限付きcgroupの作成
sudo mkdir /sys/fs/cgroup/my-container
echo "104857600" | sudo tee /sys/fs/cgroup/my-container/memory.max
# → 100MBのメモリ上限
 
echo "50000 100000" | sudo tee /sys/fs/cgroup/my-container/cpu.max
# → CPU時間の50%に制限（50ms/100ms周期）
 
# プロセスをcgroupに追加
echo $$ | sudo tee /sys/fs/cgroup/my-container/cgroup.procs
 
# リソース使用状況の確認
cat /sys/fs/cgroup/my-container/memory.current
cat /sys/fs/cgroup/my-container/cpu.stat

#!/bin/bash
# Firecracker マイクロVMの起動と管理
 
# 1. Firecrackerのダウンロードと準備
ARCH=$(uname -m)
release_url="https://github.com/firecracker-microvm/firecracker/releases"
latest=$(curl -fsSL ${release_url}/latest | grep -o 'tag/v[0-9]*\.[0-9]*\.[0-9]*' | head -1)
curl -L ${release_url}/download/${latest##tag/}/firecracker-${latest##tag/v}-${ARCH}.tgz \
  | tar -xz
 
# 2. ソケットの準備
API_SOCKET="/tmp/firecracker.socket"
rm -f $API_SOCKET
 
# 3. Firecrackerプロセスの起動
./firecracker --api-sock $API_SOCKET &
 
# 4. カーネルの設定
curl --unix-socket $API_SOCKET -X PUT \
  "http://localhost/boot-source" \
  -H "Content-Type: application/json" \
  -d '{
    "kernel_image_path": "./vmlinux",
    "boot_args": "console=ttyS0 reboot=k panic=1 pci=off"
  }'
 
# 5. ルートファイルシステムの設定
curl --unix-socket $API_SOCKET -X PUT \
  "http://localhost/drives/rootfs" \
  -H "Content-Type: application/json" \
  -d '{
    "drive_id": "rootfs",
    "path_on_host": "./ubuntu-22.04.ext4",
    "is_root_device": true,
    "is_read_only": false
  }'
 
# 6. マシンスペックの設定
curl --unix-socket $API_SOCKET -X PUT \
  "http://localhost/machine-config" \
  -H "Content-Type: application/json" \
  -d '{
    "vcpu_count": 2,
    "mem_size_mib": 256
  }'
 
# 7. ネットワークインターフェースの設定
curl --unix-socket $API_SOCKET -X PUT \
  "http://localhost/network-interfaces/eth0" \
  -H "Content-Type: application/json" \
  -d '{
    "iface_id": "eth0",
    "guest_mac": "AA:FC:00:00:00:01",
    "host_dev_name": "tap0"
  }'
 
# 8. マイクロVMの起動
curl --unix-socket $API_SOCKET -X PUT \
  "http://localhost/actions" \
  -H "Content-Type: application/json" \
  -d '{"action_type": "InstanceStart"}'
 
# 起動時間: 約125ms以下
# メモリオーバーヘッド: 約5MB
# 同時実行可能数: 1ホストあたり数千VM

# コード例4: Lambda Cold Start最適化のベストプラクティス
 
# === BAD: Cold Startが遅いパターン ===
import boto3  # トップレベルでは良い
import json
 
def handler_bad(event, context):
    # 毎回の呼び出しでクライアント生成 = 遅い
    dynamodb = boto3.resource('dynamodb')
    table = dynamodb.Table('my-table')
 
    # 毎回の接続確立 = 遅い
    import pymysql
    connection = pymysql.connect(
        host='my-rds-instance.xxx.rds.amazonaws.com',
        user='admin',
        password='secret',
        database='mydb'
    )
 
    return {"statusCode": 200, "body": "done"}
 
 
# === GOOD: Cold Start最適化パターン ===
import boto3
import json
import os
 
# グローバルスコープでリソース初期化
# → Execution Environmentの再利用時にスキップされる
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table(os.environ['TABLE_NAME'])
 
# コネクションプールも初期化フェーズで作成
import pymysql
connection = None
 
def get_connection():
    global connection
    if connection is None or not connection.open:
        connection = pymysql.connect(
            host=os.environ['DB_HOST'],
            user=os.environ['DB_USER'],
            password=os.environ['DB_PASSWORD'],
            database=os.environ['DB_NAME'],
            connect_timeout=5,
            read_timeout=10
        )
    return connection
 
def handler_good(event, context):
    # Warm Start時はグローバルスコープの初期化をスキップ
    conn = get_connection()
 
    # DynamoDBはすでに初期化済み
    response = table.get_item(Key={'id': event['id']})
 
    return {
        "statusCode": 200,
        "body": json.dumps(response.get('Item', {}))
    }
 
 
# === SnapStart (Java) の活用 ===
# Lambda SnapStart: 初期化済みスナップショットから復元
# → Java/JVMのCold Startを最大90%削減
#
# 仕組み:
# 1. 初回デプロイ時にInit phaseを実行
# 2. メモリスナップショットを Firecracker の
#    snapshot機能で保存（CRIUベース）
# 3. Cold Start時はスナップショットから復元
# 4. 起動時間: 数秒 → 数百ミリ秒に短縮

/* FreeRTOS タスク間通信の基本パターン
 * ターゲット: ESP32 (Xtensa LX6)
 * FreeRTOS v10.5.1
 */
 
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "freertos/semphr.h"
#include "esp_log.h"
 
static const char *TAG = "RTOS_DEMO";
 
/* センサーデータ構造体 */
typedef struct {
    uint32_t sensor_id;
    float    temperature;
    float    humidity;
    uint32_t timestamp_ms;
} sensor_data_t;
 
/* グローバルハンドル */
static QueueHandle_t     sensor_queue    = NULL;
static SemaphoreHandle_t i2c_mutex       = NULL;
static TaskHandle_t      sensor_task_h   = NULL;
static TaskHandle_t      process_task_h  = NULL;
static TaskHandle_t      watchdog_task_h = NULL;
 
/*
 * センサー読み取りタスク（高優先度）
 * 100ms周期で温湿度センサーからデータを読み取り、
 * キューに送信する。
 */
void sensor_read_task(void *pvParameters)
{
    sensor_data_t data;
    TickType_t    last_wake_time = xTaskGetTickCount();
    const TickType_t period     = pdMS_TO_TICKS(100); /* 100ms周期 */
 
    ESP_LOGI(TAG, "Sensor task started (priority: %d)",
             uxTaskPriorityGet(NULL));
 
    for (;;) {
        /* I2Cバスの排他アクセス（mutexで保護） */
        if (xSemaphoreTake(i2c_mutex, pdMS_TO_TICKS(50)) == pdTRUE) {
            /* センサー読み取り（ダミーデータ） */
            data.sensor_id    = 1;
            data.temperature  = 25.0f + (esp_random() % 100) / 10.0f;
            data.humidity     = 40.0f + (esp_random() % 200) / 10.0f;
            data.timestamp_ms = xTaskGetTickCount() * portTICK_PERIOD_MS;
 
            xSemaphoreGive(i2c_mutex);
 
            /* キューに送信（10ms待ち） */
            if (xQueueSend(sensor_queue, &data,
                           pdMS_TO_TICKS(10)) != pdPASS) {
                ESP_LOGW(TAG, "Queue full! Data dropped.");
            }
        } else {
            ESP_LOGW(TAG, "Failed to acquire I2C mutex");
        }
 
        /* 正確な周期実行（vTaskDelay ではなく vTaskDelayUntil を使用）
         * vTaskDelayUntil: 前回の起床時刻からの相対遅延
         *                  → 処理時間のばらつきを吸収
         * vTaskDelay:      現在からの相対遅延
         *                  → 処理時間分だけ周期がずれる
         */
        vTaskDelayUntil(&last_wake_time, period);
    }
}
 
/*
 * データ処理タスク（中優先度）
 * キューからデータを受信し、閾値判定と集約を行う。
 */
void data_process_task(void *pvParameters)
{
    sensor_data_t received;
    float temp_sum   = 0.0f;
    uint32_t count   = 0;
    const uint32_t WINDOW = 10; /* 10サンプルで平均 */
 
    ESP_LOGI(TAG, "Process task started (priority: %d)",
             uxTaskPriorityGet(NULL));
 
    for (;;) {
        /* キューからデータ受信（最大1秒待ち） */
        if (xQueueReceive(sensor_queue, &received,
                          pdMS_TO_TICKS(1000)) == pdPASS) {
            temp_sum += received.temperature;
            count++;
 
            /* 異常値の即座検出 */
            if (received.temperature > 50.0f) {
                ESP_LOGE(TAG, "ALERT! High temp: %.1f C (sensor %lu)",
                         received.temperature, received.sensor_id);
                /* ここで警報タスクに通知を送る等の処理 */
            }
 
            /* 移動平均の計算 */
            if (count >= WINDOW) {
                float avg = temp_sum / (float)count;
                ESP_LOGI(TAG, "Avg temp (last %lu): %.2f C",
                         (unsigned long)WINDOW, avg);
                temp_sum = 0.0f;
                count    = 0;
            }
        } else {
            ESP_LOGW(TAG, "No sensor data received for 1 second");
        }
    }
}
 
/*
 * ウォッチドッグタスク（最高優先度）
 * 他タスクの生存確認を行う。
 */
void watchdog_task(void *pvParameters)
{
    for (;;) {
        /* タスク状態の確認 */
        eTaskState sensor_state  = eTaskGetState(sensor_task_h);
        eTaskState process_state = eTaskGetState(process_task_h);
 
        if (sensor_state == eDeleted || sensor_state == eSuspended) {
            ESP_LOGE(TAG, "Sensor task is not running! State: %d",
                     sensor_state);
            /* タスクの再起動やシステムリセットをここで行う */
        }
 
        /* スタック使用量の監視 */
        UBaseType_t sensor_stack =
            uxTaskGetStackHighWaterMark(sensor_task_h);
        UBaseType_t process_stack =
            uxTaskGetStackHighWaterMark(process_task_h);
 
        ESP_LOGI(TAG, "Stack HWM - Sensor: %u, Process: %u",
                 sensor_stack, process_stack);
 
        if (sensor_stack < 100) {
            ESP_LOGE(TAG, "Sensor task stack nearly full!");
        }
 
        vTaskDelay(pdMS_TO_TICKS(5000)); /* 5秒周期 */
    }
}
 
/*
 * メイン関数: タスクの生成とスケジューラ起動
 */
void app_main(void)
{
    /* キューの作成（10要素） */
    sensor_queue = xQueueCreate(10, sizeof(sensor_data_t));
    configASSERT(sensor_queue != NULL);
 
    /* Mutexの作成（優先度継承あり） */
    i2c_mutex = xSemaphoreCreateMutex();
    configASSERT(i2c_mutex != NULL);
 
    /* タスク作成
     * 引数: 関数, 名前, スタックサイズ, パラメータ,
     *       優先度, ハンドル
     *
     * 優先度設計:
     *   watchdog  : 5 (最高)  - システム監視
     *   sensor    : 3 (高)    - リアルタイムデータ取得
     *   process   : 2 (中)    - データ処理
     *   idle      : 0 (最低)  - FreeRTOS内部
     */
    xTaskCreatePinnedToCore(
        watchdog_task, "watchdog", 2048, NULL, 5,
        &watchdog_task_h, 0  /* Core 0 */
    );
 
    xTaskCreatePinnedToCore(
        sensor_read_task, "sensor", 4096, NULL, 3,
        &sensor_task_h, 1    /* Core 1 */
    );
 
    xTaskCreatePinnedToCore(
        data_process_task, "process", 4096, NULL, 2,
        &process_task_h, 1   /* Core 1 */
    );
 
    ESP_LOGI(TAG, "All tasks created. Scheduler running.");
    /* ESP-IDFではapp_mainがタスクとして実行されるため、
     * vTaskStartScheduler()は不要（自動呼び出し済み）*/
}

// Rust カーネルモジュールの基本構造
// Linux 6.1+ / Rust for Linux
 
//! 簡易キャラクタデバイスモジュール
 
use kernel::prelude::*;
use kernel::{
    file::{self, File, Operations},
    io_buffer::{IoBufferReader, IoBufferWriter},
    miscdev,
    sync::{smutex::Mutex, Arc, ArcBorrow},
};
 
module! {
    type: RustCharDev,
    name: "rust_chardev",
    author: "Example Author",
    description: "A simple character device in Rust",
    license: "GPL",
}
 
/// デバイスの共有状態
struct SharedState {
    /// デバイスが保持するデータバッファ
    buffer: Mutex<Vec<u8>>,
}
 
/// モジュール本体
struct RustCharDev {
    _dev: Pin<Box<miscdev::Registration<RustCharDev>>>,
}
 
/// ファイル操作の実装
#[vtable]
impl Operations for RustCharDev {
    type OpenData = Arc<SharedState>;
    type Data = Arc<SharedState>;
 
    fn open(shared: &Arc<SharedState>, _file: &File) -> Result<Arc<SharedState>> {
        pr_info!("rust_chardev: Device opened\n");
        Ok(shared.clone())
    }
 
    fn read(
        shared: ArcBorrow<'_, SharedState>,
        _file: &File,
        writer: &mut impl IoBufferWriter,
        offset: u64,
    ) -> Result<usize> {
        let buf = shared.buffer.lock();
        let offset = offset as usize;
 
        if offset >= buf.len() {
            return Ok(0);
        }
 
        let available = &buf[offset..];
        let to_write = core::cmp::min(available.len(), writer.len());
        writer.write_slice(&available[..to_write])?;
 
        pr_info!("rust_chardev: Read {} bytes at offset {}\n", to_write, offset);
        Ok(to_write)
    }
 
    fn write(
        shared: ArcBorrow<'_, SharedState>,
        _file: &File,
        reader: &mut impl IoBufferReader,
        _offset: u64,
    ) -> Result<usize> {
        let mut buf = shared.buffer.lock();
        let len = reader.len();
        let mut data = Vec::new();
 
        // Rust の所有権システムにより:
        // - バッファオーバーフローは発生しない (Vec が自動拡張)
        // - Use-After-Free は発生しない (ライフタイム管理)
        // - データレースは発生しない (Mutex で保護)
        data.try_reserve(len)?;
        unsafe { data.set_len(len) };
        reader.read_slice(&mut data)?;
 
        *buf = data;
        pr_info!("rust_chardev: Wrote {} bytes\n", len);
        Ok(len)
    }
}
 
impl kernel::Module for RustCharDev {
    fn init(_module: &'static ThisModule) -> Result<Self> {
        pr_info!("rust_chardev: Module loaded\n");
 
        let state = Arc::try_new(SharedState {
            buffer: Mutex::new(Vec::new()),
        })?;
 
        let dev = miscdev::Registration::new_pinned(
            fmt!("rust_chardev"),
            state,
        )?;
 
        Ok(Self { _dev: dev })
    }
}
 
impl Drop for RustCharDev {
    fn drop(&mut self) {
        pr_info!("rust_chardev: Module unloaded\n");
    }
}

/* Linux PREEMPT_RT パッチを使ったリアルタイムアプリケーション
 *
 * PREEMPT_RT: Linuxをソフトリアルタイムシステムとして使う
 * 通常のLinux: スループット重視 → PREEMPT_RT: レイテンシ重視
 */
 
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <sched.h>
#include <time.h>
#include <sys/mman.h>
#include <unistd.h>
#include <errno.h>
 
#define NSEC_PER_SEC    1000000000L
#define CYCLE_TIME_NS   1000000L   /* 1ms周期 */
#define MAX_LATENCY_NS  50000L     /* 最大許容レイテンシ: 50us */
 
/* 統計情報 */
struct rt_stats {
    long min_latency_ns;
    long max_latency_ns;
    long total_latency_ns;
    long count;
    long deadline_misses;
};
 
static volatile int running = 1;
 
/* 時刻の加算ヘルパー */
static void timespec_add_ns(struct timespec *ts, long ns)
{
    ts->tv_nsec += ns;
    while (ts->tv_nsec >= NSEC_PER_SEC) {
        ts->tv_nsec -= NSEC_PER_SEC;
        ts->tv_sec++;
    }
}
 
/* 時刻差分の計算（ナノ秒） */
static long timespec_diff_ns(struct timespec *a, struct timespec *b)
{
    return (a->tv_sec - b->tv_sec) * NSEC_PER_SEC
         + (a->tv_nsec - b->tv_nsec);
}
 
/*
 * リアルタイムスレッド
 * 1ms周期で制御ループを実行する。
 */
void *rt_thread(void *arg)
{
    struct rt_stats *stats = (struct rt_stats *)arg;
    struct timespec next_period, now;
    long latency;
 
    stats->min_latency_ns = NSEC_PER_SEC; /* 初期値: 大 */
    stats->max_latency_ns = 0;
    stats->total_latency_ns = 0;
    stats->count = 0;
    stats->deadline_misses = 0;
 
    /* 現在時刻を取得して開始時刻とする */
    clock_gettime(CLOCK_MONOTONIC, &next_period);
 
    while (running) {
        /* 次の起床時刻を計算 */
        timespec_add_ns(&next_period, CYCLE_TIME_NS);
 
        /* 指定時刻まで絶対時間スリープ
         * clock_nanosleep + TIMER_ABSTIME:
         * - 相対スリープと違い、割り込みや処理遅延の影響を受けにくい
         * - シグナルで起こされてもEINTRで再試行可能
         */
        while (clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME,
                               &next_period, NULL) == EINTR)
            ; /* シグナル割り込み時はリトライ */
 
        /* 実際の起床時刻を取得 */
        clock_gettime(CLOCK_MONOTONIC, &now);
 
        /* レイテンシの計算 */
        latency = timespec_diff_ns(&now, &next_period);
 
        /* 統計の更新 */
        if (latency < stats->min_latency_ns)
            stats->min_latency_ns = latency;
        if (latency > stats->max_latency_ns)
            stats->max_latency_ns = latency;
        stats->total_latency_ns += latency;
        stats->count++;
 
        if (latency > MAX_LATENCY_NS)
            stats->deadline_misses++;
 
        /* ===== ここに制御ロジックを実装 ===== */
        /* 例: センサー読み取り → PID計算 → アクチュエータ出力 */
    }
 
    return NULL;
}
 
int main(int argc, char *argv[])
{
    pthread_t thread;
    pthread_attr_t attr;
    struct sched_param param;
    struct rt_stats stats;
    int ret;
 
    printf("=== Linux PREEMPT_RT リアルタイムデモ ===\n");
 
    /* 1. 全メモリページをロック（ページフォルト防止）
     *    リアルタイムタスクではページフォルトは許容できない。
     *    MCL_CURRENT: 現在マッピング済みの全ページをロック
     *    MCL_FUTURE: 将来マッピングされるページもロック
     */
    if (mlockall(MCL_CURRENT | MCL_FUTURE) != 0) {
        perror("mlockall failed (root権限が必要)");
        return 1;
    }
 
    /* 2. スレッド属性の設定 */
    pthread_attr_init(&attr);
 
    /* SCHED_FIFO: リアルタイムスケジューリングポリシー
     * - 優先度ベースのプリエンプティブスケジューリング
     * - 同優先度内はFIFO（先着順）
     * - SCHED_RR: 同優先度内でラウンドロビン（時分割）
     */
    pthread_attr_setschedpolicy(&attr, SCHED_FIFO);
 
    /* 優先度の設定（1-99、高いほど優先）
     * 推奨: 49以下（カーネルスレッドの邪魔を避ける）
     */
    param.sched_priority = 49;
    pthread_attr_setschedparam(&attr, &param);
 
    /* PTHREAD_EXPLICIT_SCHED: 親スレッドの属性を継承しない */
    pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
 
    /* 3. CPUアフィニティの設定（特定のCPUコアに固定） */
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(1, &cpuset); /* CPU 1 に固定 */
    pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpuset);
 
    /* 4. リアルタイムスレッドの起動 */
    ret = pthread_create(&thread, &attr, rt_thread, &stats);
    if (ret != 0) {
        fprintf(stderr, "pthread_create failed: %s\n", strerror(ret));
        fprintf(stderr, "ヒント: sudo で実行するか、\n");
        fprintf(stderr, "  /etc/security/limits.conf に\n");
        fprintf(stderr, "  'username - rtprio 99' を追加\n");
        return 1;
    }
 
    /* 5. 10秒間実行 */
    sleep(10);
    running = 0;
 
    pthread_join(thread, NULL);
 
    /* 6. 結果の表示 */
    printf("\n=== 結果 ===\n");
    printf("サンプル数:       %ld\n", stats.count);
    printf("最小レイテンシ:   %ld ns\n", stats.min_latency_ns);
    printf("最大レイテンシ:   %ld ns\n", stats.max_latency_ns);
    printf("平均レイテンシ:   %ld ns\n",
           stats.total_latency_ns / stats.count);
    printf("デッドライン超過: %ld 回\n", stats.deadline_misses);
    printf("デッドライン:     %ld ns\n", MAX_LATENCY_NS);
 
    munlockall();
    pthread_attr_destroy(&attr);
 
    return 0;
}
 
/*
 * コンパイル & 実行:
 * gcc -o rt_demo rt_demo.c -lpthread -lrt -O2
 * sudo ./rt_demo
 *
 * PREEMPT_RT カーネルの確認:
 * uname -a | grep -i preempt
 * → "PREEMPT_RT" が含まれていれば対応カーネル
 *
 * カーネル設定 (menuconfig):
 * General Setup → Preemption Model →
 *   Fully Preemptible Kernel (Real-Time)
 */