MENU
  1. ホーム
  2. Rust
  3. Rust標準ライブラリstd::osで実現するOS特化機能の詳細ガイド

Rust標準ライブラリstd::osで実現するOS特化機能の詳細ガイド

Rust

Rust言語は、安全性とパフォーマンスを両立するモダンなプログラミング言語として注目を集めています。その中でも、標準ライブラリに含まれるstd::osモジュールは、各OSに特化した機能を提供する重要な要素です。開発者はこのモジュールを活用することで、プラットフォームに依存した操作を簡潔かつ効率的に実装できます。本記事では、std::osモジュールの概要から具体的な使い方まで、初心者でも理解しやすいように解説します。これにより、クロスプラットフォーム開発や特定のOSでの最適化が求められる場面で大きな助けとなるでしょう。

目次

`std::os`モジュールとは


Rustの標準ライブラリに含まれるstd::osモジュールは、OS固有の機能やデータ型を提供する特化モジュールです。このモジュールは、一般的なクロスプラットフォーム操作を超えて、特定のOSでしかサポートされない機能を直接操作するためのインターフェースを提供します。

構成と役割


std::osモジュールは以下のようなサブモジュールで構成されています：

  • std::os::unix: Unix系OSに特化した機能を提供します。たとえば、UNIXソケットの操作やファイルのパーミッション管理などが含まれます。
  • std::os::windows: Windows環境で利用できる拡張機能を提供します。Windows特有のファイル属性やハンドル操作を含みます。
  • std::os::raw: クロスプラットフォームで使える基本的なC言語の型を提供します。Cのライブラリとの連携に便利です。

用途と利点


std::osモジュールを利用することで、以下のようなOS特化の操作が可能になります：

  • OSごとに異なるファイルパス形式の操作
  • プロセスIDや環境変数といったOS依存のシステム情報の取得
  • クロスプラットフォームアプリケーションで、OS特有の動作をカプセル化

このモジュールは、通常の標準ライブラリではカバーできない領域を補完する役割を持ち、OS特化の操作を効率的に行うための強力なツールセットとなります。

`std::os`でのファイルパス操作の基本

Rustでは、ファイルパスの操作は標準ライブラリのstd::pathモジュールで行われますが、std::osモジュールを使うことでOSに特化したパス操作が可能になります。これにより、WindowsやUnix系OSで異なるパス仕様を適切に処理できます。

Unix系OSでのファイルパス


std::os::unix::ffi::OsStrExtモジュールを使用すると、Unix系OSのファイルパスを簡単に操作できます。以下はバイト列としてパスを扱う例です：

use std::ffi::OsStr;
use std::os::unix::ffi::OsStrExt;

fn main() {
    let path = OsStr::new("/home/user/file.txt");
    let bytes = path.as_bytes();
    println!("{:?}", bytes);
}

このコードでは、Unix系のパスをバイト列形式で操作でき、低レベルなシステムとの互換性を保ちながらファイルパスを処理します。

Windowsでのファイルパス


Windows固有のパス操作はstd::os::windows::ffi::OsStringExtでサポートされます。以下の例は、Windowsの広く使われるUTF-16形式のパスを扱う方法を示します：

use std::ffi::OsString;
use std::os::windows::ffi::OsStringExt;

fn main() {
    let wide: Vec<u16> = vec![67, 58, 92, 112, 97, 116, 104, 92, 102, 105, 108, 101, 46, 116, 120, 116]; // "C:\path\file.txt"
    let os_string = OsString::from_wide(&wide);
    println!("{:?}", os_string);
}

このコードはUTF-16配列を利用してWindows形式のファイルパスを生成します。

クロスプラットフォームの考慮


クロスプラットフォームアプリケーションを開発する場合は、std::fsやstd::pathの基本機能を使用しつつ、std::osモジュールを適切に組み合わせるのが効果的です。以下は、OSに応じて異なる処理を行う例です：

use std::env;
use std::path::Path;

fn main() {
    let home_dir = if cfg!(target_os = "windows") {
        env::var("USERPROFILE").expect("Failed to get USERPROFILE")
    } else {
        env::var("HOME").expect("Failed to get HOME")
    };

    let file_path = Path::new(&home_dir).join("file.txt");
    println!("{:?}", file_path);
}

このように、std::osを活用することで、OS固有のファイルパス操作を安全かつ柔軟に実装できます。

環境変数の操作とカスタマイズ

環境変数は、プログラムの動作に影響を与える重要な設定情報を格納します。Rustの標準ライブラリstd::osモジュールを利用することで、OS特有の環境変数を柔軟に操作できます。

環境変数の取得


環境変数を取得するには、std::env::varを使用します。以下のコードは、環境変数を取得する基本的な方法を示します：

use std::env;

fn main() {
    match env::var("HOME") {
        Ok(home) => println!("Home directory: {}", home),
        Err(e) => println!("Couldn't retrieve HOME: {}", e),
    }
}

この例では、Unix系OSではHOME変数を、WindowsではUSERPROFILE変数を取得することで、ユーザーのホームディレクトリを表示できます。

環境変数の設定


環境変数を設定するには、std::env::set_varを使用します。以下は、環境変数を一時的に設定する例です：

use std::env;

fn main() {
    env::set_var("MY_VARIABLE", "RustProgramming");
    println!("MY_VARIABLE: {}", env::var("MY_VARIABLE").unwrap());
}

このコードは、新しい環境変数MY_VARIABLEを作成し、プログラム内でその値を利用します。ただし、この設定はプログラムの実行中のみ有効で、システム全体には影響を与えません。

OS特有の環境変数操作


std::os::unixやstd::os::windowsを利用すれば、OS固有の詳細な環境変数操作が可能です。以下はUnix系OSでのファイルディスクリプタ数を取得する例です：

use std::os::unix::prelude::*;

fn main() {
    if let Ok(rlimits) = std::os::unix::fs::MetadataExt::fs_readdir_limit() {
        println!("File descriptor limit: {}", rlimits);
    }
}

Windows特有の設定も同様に行えますが、注意が必要です。

安全な環境変数操作


環境変数を操作する際には、予期しないエラーを適切に処理することが重要です。std::env::var_osを使えば、Unicodeに依存しない安全な取得が可能です：

use std::env;

fn main() {
    if let Some(value) = env::var_os("MY_VARIABLE") {
        println!("Value: {:?}", value);
    } else {
        println!("Environment variable not set");
    }
}

実践例: カスタマイズ可能な設定


環境変数を利用して設定を切り替えることができます。以下は、デバッグモードを環境変数で制御する例です：

use std::env;

fn main() {
    let debug_mode = env::var("DEBUG_MODE").unwrap_or("false".to_string());
    if debug_mode == "true" {
        println!("Debug mode enabled");
    } else {
        println!("Debug mode disabled");
    }
}

このように、std::osを活用すれば、OS特有の操作を含めた柔軟な環境変数管理が可能になります。

OS固有のプロセス管理

Rustでは、std::osモジュールを活用することで、OS固有のプロセス管理を実現できます。プロセスIDの取得やプロセス間通信など、OS依存の低レベルな操作を効率的に行えるため、システムプログラムの開発に役立ちます。

プロセスIDの取得


Rustのstd::process::idを利用すると、現在のプロセスIDを簡単に取得できます：

use std::process;

fn main() {
    let pid = process::id();
    println!("Current process ID: {}", pid);
}

このコードは、現在実行中のプログラムのプロセスIDを出力します。プロセスIDは、他のプロセスとの連携やデバッグに役立ちます。

親プロセスのID取得


Unix環境では、std::os::unix::process::ParentIdを使用して親プロセスのIDを取得できます：

use std::os::unix::process::parent_id;

fn main() {
    match parent_id() {
        Some(pid) => println!("Parent process ID: {}", pid),
        None => println!("No parent process found"),
    }
}

このコードでは、親プロセスIDを取得し、プロセスの親子関係を特定できます。

プロセスの終了コード


Rustのstd::process::Commandを利用してプロセスを実行し、終了コードを取得することも可能です：

use std::process::Command;

fn main() {
    let output = Command::new("ls")
        .arg("-l")
        .output()
        .expect("Failed to execute command");

    if output.status.success() {
        println!("Command executed successfully");
    } else {
        println!("Command failed with exit code: {:?}", output.status.code());
    }
}

このコードは、Unix系OSでlsコマンドを実行し、終了ステータスを確認します。Windowsでは、コマンドをcmdやPowerShellに変更する必要があります。

プロセス間通信


プロセス間でデータをやり取りするには、標準入出力を利用します。以下の例は、プロセスにデータを渡して出力を取得する方法です：

use std::process::{Command, Stdio};
use std::io::Write;

fn main() {
    let mut process = Command::new("grep")
        .arg("Rust")
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .spawn()
        .expect("Failed to spawn process");

    if let Some(mut stdin) = process.stdin.take() {
        stdin.write_all(b"Rust is great!\nC++ is powerful.\n").expect("Failed to write to stdin");
    }

    let output = process.wait_with_output().expect("Failed to read output");
    println!("Filtered output: {}", String::from_utf8_lossy(&output.stdout));
}

この例では、grepコマンドに標準入力を渡し、フィルタリングされた結果を標準出力から取得します。

OS特化の操作


std::os::unixやstd::os::windowsを使うと、さらにOS固有のプロセス操作が可能です。たとえば、Unixではプロセスのシグナルを送ることができます：

use std::process;
use nix::sys::signal::{kill, Signal};

fn main() {
    let pid = process::id();
    println!("Sending SIGTERM to process {}", pid);

    if let Err(err) = kill(pid as i32, Signal::SIGTERM) {
        eprintln!("Failed to send signal: {}", err);
    }
}

このコードは現在のプロセスにSIGTERMを送信します（外部ライブラリnixを利用）。

まとめ


Rustのstd::osを活用することで、プロセスIDの取得、プロセス間通信、プロセスの終了コード管理など、OS特有のプロセス管理が簡単に実装できます。これにより、システムプログラミングや高度なアプリケーション開発がより効率的に行えます。

ファイルメタデータの利用と拡張

ファイルメタデータは、ファイルのプロパティや状態を管理するための重要な情報を提供します。Rustのstd::fsとstd::osモジュールを活用することで、プラットフォームに依存した詳細なファイルメタデータ操作が可能になります。

基本的なファイルメタデータの取得


std::fs::metadataを利用すると、ファイルの基本的なメタデータを取得できます：

use std::fs;

fn main() {
    let metadata = fs::metadata("example.txt").expect("Failed to read metadata");
    println!("File size: {}", metadata.len());
    println!("Is read-only: {}", metadata.permissions().readonly());
}

このコードは、指定されたファイルのサイズと読み取り専用属性を出力します。

OS固有のファイルメタデータの拡張


std::osモジュールを使用すれば、OS固有のメタデータにアクセスできます。

Unix系OSでのメタデータ操作


std::os::unix::fs::MetadataExtを利用して、ファイルの所有者やモード（パーミッション）を取得します：

use std::fs;
use std::os::unix::fs::MetadataExt;

fn main() {
    let metadata = fs::metadata("example.txt").expect("Failed to read metadata");
    println!("Owner ID: {}", metadata.uid());
    println!("Group ID: {}", metadata.gid());
    println!("Permissions (mode): {:o}", metadata.mode());
}

このコードは、ファイルの所有者ID、グループID、そしてパーミッションを表示します。

Windowsでのメタデータ操作


Windows環境では、std::os::windows::fs::MetadataExtを利用して特定の属性を取得できます：

use std::fs;
use std::os::windows::fs::MetadataExt;

fn main() {
    let metadata = fs::metadata("example.txt").expect("Failed to read metadata");
    println!("File attributes: {}", metadata.file_attributes());
    println!("Creation time: {}", metadata.creation_time());
}

このコードは、Windowsファイル属性や作成日時を取得します。

メタデータの変更


メタデータの変更にはstd::fs::set_permissionsを使用します：

use std::fs;
use std::os::unix::fs::PermissionsExt;

fn main() {
    let mut permissions = fs::metadata("example.txt")
        .expect("Failed to read metadata")
        .permissions();

    permissions.set_mode(0o644); // Unix系のモードを設定
    fs::set_permissions("example.txt", permissions).expect("Failed to set permissions");
}

このコードは、Unix系OSでファイルのパーミッションを変更します。

応用例：メタデータを用いたファイル監視


メタデータを活用して、ファイルの変更を監視するシステムを構築できます。以下は、簡単な変更監視プログラムの例です：

use std::fs;
use std::time::SystemTime;

fn main() {
    let path = "example.txt";
    let metadata = fs::metadata(path).expect("Failed to read metadata");
    let mut last_modified = metadata.modified().expect("Failed to get modified time");

    loop {
        let metadata = fs::metadata(path).expect("Failed to read metadata");
        let modified = metadata.modified().expect("Failed to get modified time");

        if modified > last_modified {
            println!("File '{}' was modified!", path);
            last_modified = modified;
        }
    }
}

このコードは、指定したファイルの最終変更時刻を監視し、変更があれば通知します。

まとめ


Rustのstd::osモジュールを活用することで、ファイルメタデータの取得と操作がより詳細に行えるようになります。これにより、OS固有の属性を考慮した柔軟なファイル管理が可能となり、システムプログラミングや高度なファイル操作を必要とするアプリケーションの開発を支援します。

標準ライブラリとサードパーティライブラリの活用

Rustの標準ライブラリは豊富な機能を提供しますが、特定のユースケースではサードパーティライブラリを併用することで開発効率をさらに向上させることができます。本セクションでは、std::osモジュールと外部ライブラリを組み合わせた高度な機能の活用例を紹介します。

標準ライブラリの限界を補うサードパーティライブラリ


標準ライブラリでは、OS固有の操作やクロスプラットフォームの複雑な機能をカバーすることは難しい場合があります。このような場合、以下のようなライブラリを活用するのが効果的です：

  • nix: Unix系システムコールのラッパーを提供し、std::os::unixを拡張します。
  • winapi: Windows特有のAPIをRustから直接操作できるライブラリです。
  • tokio: 非同期操作やファイルシステムの監視をサポートします。

Unix系OSの高度な操作例


以下は、nixライブラリを利用してプロセスシグナルを送信する例です：

use nix::sys::signal::{kill, Signal};
use nix::unistd::Pid;

fn main() {
    let pid = Pid::from_raw(12345); // 送信先プロセスID
    match kill(pid, Signal::SIGTERM) {
        Ok(_) => println!("Signal sent successfully"),
        Err(e) => eprintln!("Failed to send signal: {}", e),
    }
}

このコードは、Unix系OSでシグナルを送信するための安全で直感的な方法を提供します。

Windows環境での特化操作


winapiライブラリを活用すれば、Windowsの低レベルAPIを使用できます。以下は、ファイル属性を操作する例です：

use winapi::um::fileapi::*;
use winapi::um::winnt::*;
use std::ptr;

fn main() {
    unsafe {
        let handle = CreateFileA(
            b"example.txt\0".as_ptr() as *const i8,
            GENERIC_READ,
            0,
            ptr::null_mut(),
            OPEN_EXISTING,
            FILE_ATTRIBUTE_READONLY,
            ptr::null_mut(),
        );

        if handle == INVALID_HANDLE_VALUE {
            eprintln!("Failed to open file");
        } else {
            println!("File opened successfully");
            // ファイル操作
        }
    }
}

このコードはWindows APIを直接呼び出し、ファイル操作を実現します。

クロスプラットフォームでの利便性を向上


サードパーティライブラリを利用してクロスプラットフォーム対応を強化する例を示します。たとえば、walkdirライブラリを使用すれば、ファイルシステムの操作を簡略化できます：

use walkdir::WalkDir;

fn main() {
    for entry in WalkDir::new(".").into_iter().filter_map(|e| e.ok()) {
        println!("{}", entry.path().display());
    }
}

このコードは、ディレクトリを再帰的に探索し、すべてのファイルとフォルダのパスを出力します。

非同期処理とファイルシステム監視


tokioライブラリを用いて非同期ファイル操作を行う例です：

use tokio::fs;

#[tokio::main]
async fn main() {
    let contents = fs::read_to_string("example.txt")
        .await
        .expect("Failed to read file");
    println!("File contents: {}", contents);
}

このコードは非同期にファイルを読み取り、効率的なI/O操作を実現します。

標準ライブラリと外部ライブラリの組み合わせの利点

  • 標準ライブラリで提供される安全性と基本機能を利用しつつ、サードパーティライブラリで柔軟性と拡張性を追加。
  • std::osモジュールと外部ライブラリを組み合わせることで、OS固有の操作からクロスプラットフォーム機能の実装まで幅広く対応可能。

まとめ


Rustの標準ライブラリとサードパーティライブラリを組み合わせることで、OS特化の機能とクロスプラットフォームの利便性を最大限に活用できます。このアプローチは、開発効率を向上させ、より強力で柔軟なアプリケーションの実現を可能にします。

`std::os`を使ったエラー処理のベストプラクティス

Rustでは、エラー処理が言語の中核に組み込まれており、安全で明確なエラーハンドリングが可能です。特に、std::osモジュールを利用したOS特有の操作では、慎重なエラー処理が重要です。本セクションでは、OS固有のエラーを適切に処理するための方法を解説します。

エラー処理の基本: `Result`型


Rustの標準ライブラリでは、エラーをResult型で表現します。以下は、ファイル操作で発生する可能性のあるエラーを処理する例です：

use std::fs::File;

fn main() {
    match File::open("example.txt") {
        Ok(file) => println!("File opened successfully: {:?}", file),
        Err(e) => eprintln!("Error opening file: {}", e),
    }
}

このコードは、ファイルが見つからない場合や権限がない場合などに適切なエラー情報を表示します。

OS特有のエラーの処理


std::osモジュールを利用する場合、OS固有のエラーコードやメッセージを処理する必要があります。以下は、Unix系OSでのエラーコードの処理例です：

Unix系OSでのエラーコード取得

use std::os::unix::io::AsRawFd;
use std::fs::File;
use libc;

fn main() {
    let file = File::open("nonexistent.txt");
    match file {
        Ok(_) => println!("File opened successfully"),
        Err(e) => unsafe {
            let errno = *libc::__errno_location();
            eprintln!("Error opening file: {} (errno: {})", e, errno);
        },
    }
}

このコードは、Unix系システムのerrnoを取得し、エラーコードを出力します。

Windows環境でのエラーコード取得

use winapi::um::errhandlingapi::GetLastError;

fn main() {
    let error_code = unsafe { GetLastError() };
    if error_code != 0 {
        eprintln!("Windows-specific error occurred: {}", error_code);
    } else {
        println!("No error detected");
    }
}

Windows特有のエラーコードを取得して出力する例です。エラーコードは詳細なトラブルシューティングに役立ちます。

OS固有のエラーをカスタマイズ


Rustのカスタムエラー型を定義することで、OS固有のエラーをわかりやすく表現できます：

use std::fmt;

#[derive(Debug)]
enum OSError {
    UnixError(i32),
    WindowsError(u32),
}

impl fmt::Display for OSError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            OSError::UnixError(errno) => write!(f, "Unix error: {}", errno),
            OSError::WindowsError(code) => write!(f, "Windows error: {}", code),
        }
    }
}

fn main() {
    let os_error = if cfg!(unix) {
        OSError::UnixError(2)
    } else {
        OSError::WindowsError(5)
    };

    println!("Custom error: {}", os_error);
}

このコードは、OSに応じたエラーをカスタム型で統一的に扱う方法を示します。

エラー処理のベストプラクティス

  1. 明示的なエラー処理: match式を使ってエラーを詳細に処理する。
  2. エラーの伝播: ?演算子を利用してエラーを簡潔に伝播させる。
  3. ログ記録: logクレートを使用してエラーを記録し、後でデバッグ可能にする。
  4. OS特有のエラー対応: 必要に応じてOS特有のエラーコードを取得し、詳細なエラー情報を提供する。

実践例: ファイル操作でのエラー処理

use std::fs;
use std::io;

fn read_file(path: &str) -> Result<String, io::Error> {
    let content = fs::read_to_string(path)?;
    Ok(content)
}

fn main() {
    match read_file("example.txt") {
        Ok(content) => println!("File content:\n{}", content),
        Err(e) => eprintln!("Error reading file: {}", e),
    }
}

このコードは、エラーが発生した場合でもプログラムをクラッシュさせず、適切に対応します。

まとめ


std::osを使用する際のエラー処理は、安全性と柔軟性を兼ね備えたRustのエラーハンドリングモデルを活かすことで、効率的かつ信頼性の高いプログラムを実現できます。OS固有のエラーに適切に対応することで、システムのトラブルシューティングが大幅に向上します。

実践：クロスプラットフォームアプリケーションの開発

クロスプラットフォームアプリケーションを開発する際、Rustのstd::osモジュールはOSごとに異なる特性を考慮しながら柔軟なコードを記述するための重要なツールとなります。本セクションでは、std::osを活用してクロスプラットフォームアプリケーションを構築する具体例を示します。

アプリケーションの要件


開発するアプリケーションの要件を以下に定義します：

  1. ユーザーのホームディレクトリにログファイルを作成する。
  2. ファイル操作が各OSで適切に動作するように設計する。
  3. ログにOS特有の情報（プロセスID、環境変数など）を記録する。

ホームディレクトリの取得


Rustの標準ライブラリを活用して、OSに応じたホームディレクトリを取得します：

use std::env;
use std::path::PathBuf;

fn get_home_directory() -> PathBuf {
    if cfg!(target_os = "windows") {
        env::var("USERPROFILE").expect("Failed to get USERPROFILE").into()
    } else {
        env::var("HOME").expect("Failed to get HOME").into()
    }
}

このコードは、WindowsではUSERPROFILE、Unix系ではHOMEを利用してホームディレクトリを取得します。

ログファイルの作成


取得したホームディレクトリにログファイルを作成します：

use std::fs::OpenOptions;
use std::io::Write;

fn create_log_file() -> std::io::Result<()> {
    let home_dir = get_home_directory();
    let log_path = home_dir.join("app.log");

    let mut file = OpenOptions::new()
        .create(true)
        .write(true)
        .append(true)
        .open(&log_path)?;

    writeln!(file, "Application started.")?;
    Ok(())
}

このコードは、既存のログファイルがあれば追記し、なければ新しいログファイルを作成します。

OS特有の情報の記録


各OSのプロセスIDや環境変数をログに記録します：

use std::process;

fn log_os_specific_info() -> std::io::Result<()> {
    let home_dir = get_home_directory();
    let log_path = home_dir.join("app.log");

    let mut file = OpenOptions::new()
        .create(true)
        .write(true)
        .append(true)
        .open(&log_path)?;

    let pid = process::id();
    writeln!(file, "Process ID: {}", pid)?;

    if cfg!(target_os = "windows") {
        if let Ok(temp) = env::var("TEMP") {
            writeln!(file, "TEMP directory: {}", temp)?;
        }
    } else {
        if let Ok(shell) = env::var("SHELL") {
            writeln!(file, "Shell: {}", shell)?;
        }
    }

    Ok(())
}

このコードは、WindowsならTEMPディレクトリ、Unix系ならシェル環境を記録します。

クロスプラットフォームアプリケーションの実行


これらの機能を統合してアプリケーションを実行します：

fn main() {
    if let Err(e) = create_log_file() {
        eprintln!("Error creating log file: {}", e);
    }

    if let Err(e) = log_os_specific_info() {
        eprintln!("Error logging OS-specific info: {}", e);
    }

    println!("Application has started. Check app.log for details.");
}

このコードを実行すると、app.logにアプリケーションの実行開始やOS特有の情報が記録されます。

実践結果


アプリケーションを実行すると、以下のようなログが作成されます（例：Unix系OS）：

Application started.
Process ID: 12345
Shell: /bin/bash

Windows環境では、TEMPディレクトリが記録されるログが生成されます。

まとめ


Rustのstd::osモジュールを活用することで、クロスプラットフォーム対応のアプリケーションを効率的に構築できます。OS固有の操作を抽象化しながら柔軟なコードを記述できるため、さまざまな環境で動作する信頼性の高いアプリケーションを開発可能です。

まとめ

本記事では、Rustのstd::osモジュールを活用したOS特化機能の利用方法について詳しく解説しました。標準ライブラリのstd::osを利用することで、ファイルパス操作、環境変数管理、プロセスの制御、ファイルメタデータの操作、クロスプラットフォーム開発が効率的に実現できることを確認しました。

特に、OSごとの特化操作とクロスプラットフォームアプリケーションの構築方法について具体例を示すことで、実際の開発での活用方法が明確になったはずです。Rustの安全性と柔軟性を活かし、std::osを効果的に使うことで、OS依存の複雑な問題を解決し、より強力なアプリケーションを構築できるようになるでしょう。

これからのプロジェクトにstd::osを活用し、開発効率を向上させてください。

Rust
標準ライブラリ Rust OS特化機能

コメント

コメントする

目次