Return to diskimage_raw.cpp CVS log

Up to [Isaki's NoNo m68k/m88k emulator] / nono / host

Annotation of nono/host/diskimage_raw.cpp, revision 1.1

1.1     ! root        1: //
        !             2: // nono
        !             3: // Copyright (C) 2021 nono project
        !             4: // Licensed under nono-license.txt
        !             5: //
        !             6: 
        !             7: //
        !             8: // ディスクイメージ (生イメージ形式)
        !             9: //
        !            10: 
        !            11: #include "diskimage_raw.h"
        !            12: #include <fcntl.h>
        !            13: #include <sys/stat.h>
        !            14: #include <sys/mman.h>
        !            15: 
        !            16: // コンストラクタ
        !            17: DiskImageRaw::DiskImageRaw(const std::string& pathname_)
        !            18:        : inherited(DiskImage::Type::Raw)
        !            19: {
        !            20:        pathname = pathname_;
        !            21:        memlen = (off_t)-1;
        !            22: }
        !            23: 
        !            24: // デストラクタ
        !            25: DiskImageRaw::~DiskImageRaw()
        !            26: {
        !            27:        Close();
        !            28: }
        !            29: 
        !            30: // このディスクイメージのサイズと書き込み可能かどうかを返す。
        !            31: // Open() 前でも動作する。
        !            32: int
        !            33: DiskImageRaw::GetInfo(off_t *sizep, bool *w_ok)
        !            34: {
        !            35:        // ファイルサイズは未取得なら取得
        !            36:        if (memlen == (off_t)-1) {
        !            37:                struct stat st;
        !            38: 
        !            39:                if (stat(pathname.c_str(), &st) < 0) {
        !            40:                        warn("%s: stat failed", pathname.c_str());
        !            41:                        return -1;
        !            42:                }
        !            43:                memlen = st.st_size;
        !            44:        }
        !            45:        *sizep = memlen;
        !            46: 
        !            47:        // ファイルのパーミッション
        !            48:        int r = access(pathname.c_str(), W_OK);
        !            49:        if (r == 0) {
        !            50:                *w_ok = true;
        !            51:        } else if (errno == EACCES) {
        !            52:                *w_ok = false;
        !            53:        } else {
        !            54:                warn("%s: access failed", pathname.c_str());
        !            55:                return -1;
        !            56:        }
        !            57: 
        !            58:        return 0;
        !            59: }
        !            60: 
        !            61: // オープン
        !            62: bool
        !            63: DiskImageRaw::Open(bool read_only)
        !            64: {
        !            65:        int openmode;
        !            66:        int prot;
        !            67: 
        !            68:        assert(pathname.empty() == false);
        !            69: 
        !            70:        if (read_only) {
        !            71:                openmode = O_RDONLY;
        !            72:                prot = PROT_READ;
        !            73:        } else {
        !            74:                openmode = O_RDWR;
        !            75:                prot = PROT_READ | PROT_WRITE;
        !            76:        }
        !            77: 
        !            78:        fd = open(pathname.c_str(), openmode);
        !            79:        if (fd < 0) {
        !            80:                warn("%s", pathname.c_str());
        !            81:                return false;
        !            82:        }
        !            83: 
        !            84:        // ファイルサイズは未取得なら取得
        !            85:        if (memlen == (off_t)-1) {
        !            86:                struct stat st;
        !            87: 
        !            88:                if (fstat(fd, &st) < 0) {
        !            89:                        warn("%s: stat failed", pathname.c_str());
        !            90:                        fd.Close();
        !            91:                        return false;
        !            92:                }
        !            93:                memlen = st.st_size;
        !            94:        }
        !            95: 
        !            96:        // mmap
        !            97:        void *m = mmap(NULL, (size_t)memlen, prot, MAP_SHARED, fd, 0);
        !            98:        if (m == MAP_FAILED) {
        !            99:                warn("%s: mmap failed", pathname.c_str());
        !           100:                fd.Close();
        !           101:                return false;
        !           102:        }
        !           103:        mem = (uint8 *)m;
        !           104: 
        !           105:        return true;
        !           106: }
        !           107: 
        !           108: bool
        !           109: DiskImageRaw::Read(void *buf, off_t offset, size_t size)
        !           110: {
        !           111:        if (__predict_false(fd < 0)) {
        !           112:                return false;
        !           113:        }
        !           114: 
        !           115:        memcpy(buf, &mem[offset], size);
        !           116:        return true;
        !           117: }
        !           118: 
        !           119: bool
        !           120: DiskImageRaw::Write(const void *buf, off_t offset, size_t size)
        !           121: {
        !           122:        if (__predict_false(fd < 0)) {
        !           123:                return false;
        !           124:        }
        !           125: 
        !           126:        memcpy(&mem[offset], buf, size);
        !           127:        return true;
        !           128: }
        !           129: 
        !           130: void
        !           131: DiskImageRaw::Close()
        !           132: {
        !           133:        if (fd >= 0) {
        !           134:                munmap(mem, (size_t)memlen);
        !           135:                fd.Close();
        !           136:        }
        !           137: }
        !           138: 
        !           139: off_t
        !           140: DiskImageRaw::GetSize() const
        !           141: {
        !           142:        return memlen;
        !           143: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.