# straceでシステムコールを観察（Linux）
# "hello"を出力する際のsyscallを観察
 
$ strace echo "hello"
execve("/usr/bin/echo", ["echo", "hello"], ...) = 0
brk(NULL)                               = 0x55a123456000
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
fstat(3, {st_mode=S_IFREG|0644, ...})   = 0
mmap(NULL, 76888, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7f1234567000
close(3)                                = 0
# ... (共有ライブラリのロード)
write(1, "hello\n", 6)                  = 6
close(1)                                = 0
close(2)                                = 0
exit_group(0)                           = ?

// C言語でシステムコールを直接呼び出す例
 
#include <unistd.h>
#include <sys/syscall.h>
#include <fcntl.h>
#include <stdio.h>
 
int main() {
    // 方法1: ライブラリ関数経由（通常）
    int fd = open("test.txt", O_RDONLY);
 
    // 方法2: syscall() で直接呼び出し
    int fd2 = syscall(SYS_openat, AT_FDCWD, "test.txt", O_RDONLY);
 
    // 方法3: インラインアセンブリ（x86_64）
    // 通常は使わないが、仕組みの理解に有用
    long result;
    char *msg = "Hello from syscall!\n";
    __asm__ volatile (
        "mov $1, %%rax\n"    // syscall番号: write = 1
        "mov $1, %%rdi\n"    // fd: stdout = 1
        "mov %1, %%rsi\n"    // バッファ
        "mov $20, %%rdx\n"   // サイズ
        "syscall\n"          // syscall命令
        "mov %%rax, %0\n"
        : "=r" (result)
        : "r" (msg)
        : "rax", "rdi", "rsi", "rdx"
    );
 
    printf("syscall returned: %ld\n", result);
    return 0;
}

# Pythonでシステムコールの挙動を確認
import os
import sys
 
# ファイルディスクリプタの確認
print(f"stdin:  fd={sys.stdin.fileno()}")    # 0
print(f"stdout: fd={sys.stdout.fileno()}")   # 1
print(f"stderr: fd={sys.stderr.fileno()}")   # 2
 
# os.open() は内部でopen() syscallを呼ぶ
fd = os.open("test.txt", os.O_CREAT | os.O_WRONLY, 0o644)
os.write(fd, b"Hello from Python syscall!\n")
os.close(fd)
 
# /proc/self/syscall で現在のsyscallを確認（Linux）
# /proc/self/fd でオープンしているファイルを確認
try:
    fds = os.listdir("/proc/self/fd")
    print(f"Open file descriptors: {fds}")
except FileNotFoundError:
    print("Not running on Linux")
 
# プロセス情報の取得
print(f"PID: {os.getpid()}")
print(f"PPID: {os.getppid()}")
print(f"UID: {os.getuid()}")
print(f"GID: {os.getgid()}")

# コンテナの原理を手動で体験（Linux）
 
# 1. 新しいnamespaceでプロセスを起動
sudo unshare --pid --fork --mount-proc /bin/bash
 
# 2. ps を実行すると、自プロセスしか見えない
ps aux
# PID 1 が bash になっている（隔離されている）
 
# 3. cgroupでメモリ制限を設定
sudo mkdir /sys/fs/cgroup/memory/mycontainer
echo 100M > /sys/fs/cgroup/memory/mycontainer/memory.limit_in_bytes
echo $$ > /sys/fs/cgroup/memory/mycontainer/cgroup.procs
 
# 4. ネットワークnamespaceの作成
sudo ip netns add testns
sudo ip netns exec testns ip addr
# → ループバックインターフェースのみの隔離されたネットワーク

# straceでシステムコールを観察（Linux）
strace ls /tmp 2>&1 | head -30
 
# macOS の場合は dtruss
sudo dtruss ls /tmp 2>&1 | head -30
 
# 観察ポイント:
# 1. execve() → プログラムの起動
# 2. openat() → ファイルを開く
# 3. getdents() → ディレクトリエントリを読む
# 4. write() → 結果を出力
# 5. close() → ファイルを閉じる
 
# 課題: 以下のコマンドのsyscallを比較せよ
# - echo "hello" vs printf "hello"
# - cat file vs less file
 
# 発展課題: syscallの統計を取る
strace -c ls /tmp 2>&1
# → 各syscallの呼び出し回数、所要時間を集計
 
# 特定のsyscallだけをフィルタリング
strace -e trace=open,read,write cat /etc/passwd 2>&1

# Linuxカーネルモジュールの確認
 
# 現在ロードされているモジュールの一覧
lsmod
 
# 特定のモジュールの情報
modinfo ext4
 
# モジュールの依存関係
modprobe --show-depends usb_storage
 
# /proc/modules と lsmod の関係
cat /proc/modules | head -10
# → lsmod は /proc/modules を整形して表示しているだけ

// 最小のLinuxカーネルモジュール（教育用）
// ファイル名: hello_module.c
 
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
 
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Student");
MODULE_DESCRIPTION("Hello World Kernel Module");
 
static int __init hello_init(void) {
    printk(KERN_INFO "Hello from kernel module!\n");
    return 0;
}
 
static void __exit hello_exit(void) {
    printk(KERN_INFO "Goodbye from kernel module!\n");
}
 
module_init(hello_init);
module_exit(hello_exit);
 
// Makefile:
// obj-m += hello_module.o
// all:
//     make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
// clean:
//     make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
 
// ビルドとロード:
// make
// sudo insmod hello_module.ko
// dmesg | tail  → "Hello from kernel module!"
// sudo rmmod hello_module
// dmesg | tail  → "Goodbye from kernel module!"

# Linuxの内部状態を探索
 
# 1. CPU情報
cat /proc/cpuinfo | grep "model name" | head -1
nproc  # CPUコア数
 
# 2. メモリ情報
free -h
cat /proc/meminfo | head -10
 
# 3. プロセス情報
ps aux --sort=-%mem | head -10  # メモリ使用量トップ10
ps aux --sort=-%cpu | head -10  # CPU使用量トップ10
 
# 4. ファイルシステム情報
df -h            # ディスク使用量
mount | head -20 # マウント情報
 
# 5. ネットワーク情報
ss -tlnp        # リスニングポート（Linux）
# netstat -tlnp  # 旧コマンド
 
# 6. カーネル情報
uname -a         # カーネルバージョン
cat /proc/version
 
# 7. システムのブート時間
uptime
who -b
 
# 課題: 上記の情報を収集するスクリプトを作成し、
#       「サーバー健康診断レポート」を生成せよ

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md

# チーム間のAPI契約定義
from dataclasses import dataclass
from typing import List, Optional
from enum import Enum
 
class Priority(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    CRITICAL = "critical"
 
@dataclass
class APIContract:
    """チーム間のAPI契約"""
    endpoint: str
    method: str
    owner_team: str
    consumers: List[str]
    sla_ms: int  # レスポンスタイムSLA
    priority: Priority
 
    def validate_sla(self, actual_ms: int) -> bool:
        """SLA準拠の確認"""
        return actual_ms <= self.sla_ms
 
    def to_openapi(self) -> dict:
        """OpenAPI形式で出力"""
        return {
            'path': self.endpoint,
            'method': self.method,
            'x-owner': self.owner_team,
            'x-consumers': self.consumers,
            'x-sla-ms': self.sla_ms
        }
 
# 使用例
contracts = [
    APIContract(
        endpoint="/api/v1/users",
        method="GET",
        owner_team="user-team",
        consumers=["order-team", "notification-team"],
        sla_ms=200,
        priority=Priority.HIGH
    ),
    APIContract(
        endpoint="/api/v1/orders",
        method="POST",
        owner_team="order-team",
        consumers=["payment-team", "inventory-team"],
        sla_ms=500,
        priority=Priority.CRITICAL
    )
]

# セキュアコーディング例
import hashlib
import secrets
import hmac
from typing import Optional
 
class SecurityUtils:
    """セキュリティユーティリティ"""
 
    @staticmethod
    def generate_token(length: int = 32) -> str:
        """暗号学的に安全なトークン生成"""
        return secrets.token_urlsafe(length)
 
    @staticmethod
    def hash_password(password: str, salt: Optional[str] = None) -> tuple:
        """パスワードのハッシュ化"""
        if salt is None:
            salt = secrets.token_hex(16)
        hashed = hashlib.pbkdf2_hmac(
            'sha256',
            password.encode('utf-8'),
            salt.encode('utf-8'),
            iterations=100000
        )
        return hashed.hex(), salt
 
    @staticmethod
    def verify_password(password: str, hashed: str, salt: str) -> bool:
        """パスワードの検証"""
        new_hash, _ = SecurityUtils.hash_password(password, salt)
        return hmac.compare_digest(new_hash, hashed)
 
    @staticmethod
    def sanitize_input(value: str) -> str:
        """入力値のサニタイズ"""
        dangerous_chars = ['<', '>', '"', "'", '&', '\\']
        result = value
        for char in dangerous_chars:
            result = result.replace(char, '')
        return result.strip()
 
# 使用例
token = SecurityUtils.generate_token()
hashed, salt = SecurityUtils.hash_password("my_password")
is_valid = SecurityUtils.verify_password("my_password", hashed, salt)