/* This file is part of apfs-fuse, a read-only implementation of APFS (Apple File System) for FUSE. Copyright (C) 2017 Simon Gander Apfs-fuse is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version. Apfs-fuse is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with apfs-fuse. If not, see . */ #include #include #include #include #include #include "ApfsDir.h" #include "ApfsVolume.h" #include "ApfsContainer.h" #include "BTree.h" #include "Util.h" #ifndef _MSC_VER template void strcpy_s(char (&dst)[L], const char *src) { strncpy(dst, src, L - 1); dst[L - 1] = 0; } #endif ApfsDir::Inode::Inode() { obj_id = 0; parent_id = 0; private_id = 0; create_time = 0; mod_time = 0; change_time = 0; access_time = 0; internal_flags = 0; nchildren_nlink = 0; default_protection_class = 0; write_generation_counter = 0; bsd_flags = 0; owner = 0; group = 0; mode = 0; uncompressed_size = 0; snap_xid = 0; delta_tree_oid = 0; prev_fsize = 0; ds_size = 0; ds_alloced_size = 0; ds_default_crypto_id = 0; ds_total_bytes_written = 0; ds_total_bytes_read = 0; memset(fs_uuid, 0, sizeof(fs_uuid)); sparse_bytes = 0; document_id = 0; rdev = 0; optional_present_flags = 0; /* ino = nullptr; */ } ApfsDir::Inode::Inode(const ApfsDir::Inode& o) { obj_id = o.obj_id; parent_id = o.parent_id; private_id = o.private_id; create_time = o.create_time; mod_time = o.mod_time; change_time = o.change_time; access_time = o.access_time; internal_flags = o.internal_flags; nchildren_nlink = o.nchildren_nlink; default_protection_class = o.default_protection_class; write_generation_counter = o.write_generation_counter; bsd_flags = o.bsd_flags; owner = o.owner; group = o.group; mode = o.mode; uncompressed_size = o.uncompressed_size; snap_xid = o.snap_xid; delta_tree_oid = o.delta_tree_oid; prev_fsize = o.prev_fsize; // FinderInfo ds_size = o.ds_size; ds_alloced_size = o.ds_alloced_size; ds_default_crypto_id = o.ds_default_crypto_id; ds_total_bytes_written = o.ds_total_bytes_written; ds_total_bytes_read = o.ds_total_bytes_read; // j_dir_stats_val_t dir_stats; memcpy(fs_uuid, o.fs_uuid, sizeof(apfs_uuid_t)); sparse_bytes = o.sparse_bytes; document_id = o.document_id;; rdev = o.rdev; name = o.name; optional_present_flags = o.optional_present_flags; /* ino_val_data = o.ino_val_data; ino = reinterpret_cast(ino_val_data.data()); */ } ApfsDir::DirRec::DirRec() { parent_id = 0; hash = 0; file_id = 0; date_added = 0; sibling_id = 0; flags = 0; has_sibling_id = false; } ApfsDir::DirRec::DirRec(const ApfsDir::DirRec& o) { parent_id = o.parent_id; hash = o.hash; name = o.name; file_id = o.file_id; date_added = o.date_added; sibling_id = o.sibling_id; flags = o.flags; has_sibling_id = o.has_sibling_id; } ApfsDir::ApfsDir(ApfsVolume &vol) : m_vol(vol), m_fs_tree(vol.fstree()) { m_txt_fmt = vol.getTextFormat(); m_blksize = vol.getContainer().GetBlocksize(); m_blksize_sh = log2(m_blksize); m_blksize_mask_lo = m_blksize - 1; m_blksize_mask_hi = ~m_blksize_mask_lo; m_tmp_blk.resize(m_blksize); // m_bt.EnableDebugOutput(); } ApfsDir::~ApfsDir() { } bool ApfsDir::GetInode(ApfsDir::Inode& res, uint64_t inode) { BTreeEntry bte; j_inode_key_t key; bool rc; key.hdr.obj_id_and_type = APFS_TYPE_ID(APFS_TYPE_INODE, inode); rc = m_fs_tree.Lookup(bte, &key, sizeof(j_inode_key_t), CompareStdDirKey, this, true); if (!rc || (bte.val == nullptr)) return false; // const uint8_t *idata = reinterpret_cast(bte.val); const j_inode_val_t *obj = reinterpret_cast(bte.val); res.obj_id = inode; res.parent_id = obj->parent_id; res.private_id = obj->private_id; res.create_time = obj->create_time; res.mod_time = obj->mod_time; res.change_time = obj->change_time; res.access_time = obj->access_time; res.internal_flags = obj->internal_flags; res.nchildren_nlink = obj->nchildren; res.default_protection_class = obj->default_protection_class; res.write_generation_counter = obj->write_generation_counter; res.bsd_flags = obj->bsd_flags; res.owner = obj->owner; res.group = obj->group; res.mode = obj->mode; res.uncompressed_size = obj->uncompressed_size; // internal_flags & 0x00200000 => pad2 = uncompressed_size ? if (bte.val_len > sizeof(j_inode_val_t)) { const xf_blob_t *xf_hdr = reinterpret_cast(obj->xfields); const x_field_t *xf = reinterpret_cast(xf_hdr->xf_data); const uint8_t *xdata = obj->xfields + sizeof(xf_blob_t) + xf_hdr->xf_num_exts * sizeof(x_field_t); uint16_t n; for (n = 0; n < xf_hdr->xf_num_exts; n++) { switch (xf[n].x_type) { case INO_EXT_TYPE_SNAP_XID: assert(xf[n].x_size == sizeof(uint64_t)); res.snap_xid = bswap_le(*reinterpret_cast(xdata)); res.optional_present_flags |= Inode::INO_HAS_SNAP_XID; break; case INO_EXT_TYPE_DELTRA_TREE_OID: assert(xf[n].x_size == sizeof(uint64_t)); res.delta_tree_oid = bswap_le(*reinterpret_cast(xdata)); res.optional_present_flags |= Inode::INO_HAS_DELTA_TREE_OID; break; case INO_EXT_TYPE_DOCUMENT_ID: assert(xf[n].x_size == sizeof(uint32_t)); res.document_id = bswap_le(*reinterpret_cast(xdata)); res.optional_present_flags |= Inode::INO_HAS_DOCUMENT_ID; break; case INO_EXT_TYPE_NAME: res.name.assign(reinterpret_cast(xdata), xf[n].x_size); res.optional_present_flags |= Inode::INO_HAS_NAME; break; case INO_EXT_TYPE_PREV_FSIZE: assert(xf[n].x_size == sizeof(uint64_t)); res.prev_fsize = bswap_le(*reinterpret_cast(xdata)); res.optional_present_flags |= Inode::INO_HAS_PREV_FSIZE; break; case INO_EXT_TYPE_FINDER_INFO: // TODO break; case INO_EXT_TYPE_DSTREAM: { assert(xf[n].x_size == sizeof(j_dstream_t)); const j_dstream_t *ds = reinterpret_cast(xdata); res.ds_size = ds->size; res.ds_alloced_size = ds->alloced_size; res.ds_default_crypto_id = ds->default_crypto_id; res.ds_total_bytes_written = ds->total_bytes_written; res.ds_total_bytes_read = ds->total_bytes_read; res.optional_present_flags |= Inode::INO_HAS_DSTREAM; } break; case INO_EXT_TYPE_DIR_STATS_KEY: // TODO break; case INO_EXT_TYPE_FS_UUID: assert(xf[n].x_size == sizeof(apfs_uuid_t)); memcpy(res.fs_uuid, xdata, sizeof(apfs_uuid_t)); res.optional_present_flags |= Inode::INO_HAS_FS_UUID; break; case INO_EXT_TYPE_SPARSE_BYTES: assert(xf[n].x_size == sizeof(uint64_t)); res.sparse_bytes = bswap_le(*reinterpret_cast(xdata)); res.optional_present_flags |= Inode::INO_HAS_SPARSE_BYTES; break; default: std::cerr << "Warning: Unknown XF " << xf[n].x_type << " at inode " << inode << std::endl; break; } xdata += ((xf[n].x_size + 7) & ~7); } } return true; } bool ApfsDir::ListDirectory(std::vector &dir, uint64_t inode) { uint8_t skey_buf[0x500]; BTreeIterator it; BTreeEntry bte; bool rc; uint64_t skey; const j_key_t *k; const j_drec_val_t *v; skey = APFS_TYPE_ID(APFS_TYPE_DIR_REC, inode); dir.clear(); if (m_txt_fmt & 9) { j_drec_hashed_key_t *key = reinterpret_cast(skey_buf); key->hdr.obj_id_and_type = skey; key->name_len_and_hash = 0; key->name[0] = 0; rc = m_fs_tree.GetIterator(it, key, sizeof(j_drec_hashed_key_t), CompareStdDirKey, this); } else { j_drec_key_t *key = reinterpret_cast(skey_buf); key->hdr.obj_id_and_type = skey; key->name_len = 0; key->name[0] = 0; rc = m_fs_tree.GetIterator(it, key, sizeof(j_drec_key_t), CompareStdDirKey, this); } if (!rc) return false; for (;;) { DirRec e; rc = it.GetEntry(bte); if (!rc) break; if (g_debug & Dbg_Dir) { DumpBuffer(reinterpret_cast(bte.key), bte.key_len, "entry key"); DumpBuffer(reinterpret_cast(bte.val), bte.val_len, "entry val"); } k = reinterpret_cast(bte.key); if (k->obj_id_and_type != skey) break; e.parent_id = k->obj_id_and_type & OBJ_ID_MASK; if (m_txt_fmt != 0) { const j_drec_hashed_key_t *hk = reinterpret_cast(bte.key); e.hash = hk->name_len_and_hash; e.name = reinterpret_cast(hk->name); } else { const j_drec_key_t *rk = reinterpret_cast(bte.key); e.hash = 0; e.name = reinterpret_cast(rk->name); } // assert(res.val_len == sizeof(APFS_Name)); v = reinterpret_cast(bte.val); e.file_id = v->file_id; e.date_added = v->date_added; e.flags = v->flags; if (bte.val_len > sizeof(j_drec_val_t)) { const xf_blob_t *xf_hdr = reinterpret_cast(v->xfields); const x_field_t *xf = reinterpret_cast(xf_hdr->xf_data); const uint8_t *xdata = v->xfields + sizeof(xf_blob_t) + xf_hdr->xf_num_exts * sizeof(x_field_t); uint16_t n; for (n = 0; n < xf_hdr->xf_num_exts; n++) { switch (xf[n].x_type) { case DREC_EXT_TYPE_SIBLING_ID: assert(xf[n].x_size == sizeof(uint64_t)); e.sibling_id = bswap_le(*reinterpret_cast(xdata)); e.has_sibling_id = true; break; default: std::cerr << "Warning: Unknown XF " << xf[n].x_type << " at drec " << e.file_id << std::endl; break; } xdata += ((xf[n].x_size + 7) & ~7); } } dir.push_back(e); it.next(); } return true; } bool ApfsDir::LookupName(ApfsDir::DirRec& res, uint64_t parent_id, const char* name) { bool rc; BTreeEntry e; uint8_t srch_key_buf[0x500]; size_t name_len = strlen(name) + 1; if (name_len > 0x400) return false; res.parent_id = parent_id; res.name = name; if (m_txt_fmt & 9) { j_drec_hashed_key_t *skey = reinterpret_cast(srch_key_buf); skey->hdr.obj_id_and_type = APFS_TYPE_ID(APFS_TYPE_DIR_REC, parent_id); skey->name_len_and_hash = HashFilename(reinterpret_cast(name), static_cast(name_len), (m_txt_fmt & APFS_INCOMPAT_CASE_INSENSITIVE) != 0); memcpy(skey->name, name, name_len); if (g_debug & Dbg_Dir) { std::cout << "Lookup hashed key: key=" << skey->hdr.obj_id_and_type << " hash=" << skey->name_len_and_hash << " name='" << reinterpret_cast(skey->name) << "'" << std::endl; dump_utf8(std::cout, skey->name); } res.hash = skey->name_len_and_hash; rc = m_fs_tree.Lookup(e, skey, sizeof(j_drec_hashed_key_t) + (skey->name_len_and_hash & J_DREC_LEN_MASK), CompareStdDirKey, this, true); } else { j_drec_key_t *skey = reinterpret_cast(srch_key_buf); skey->hdr.obj_id_and_type = parent_id | (static_cast(APFS_TYPE_DIR_REC) << OBJ_TYPE_SHIFT); skey->name_len = static_cast(name_len); memcpy(skey->name, name, name_len); if (g_debug & Dbg_Dir) { std::cout << "Lookup key: key=" << skey->hdr.obj_id_and_type << " name_len=" << skey->name_len << " name='" << reinterpret_cast(skey->name) << "'" << std::endl; dump_utf8(std::cout, skey->name); } res.hash = 0; rc = m_fs_tree.Lookup(e, skey, sizeof(j_drec_key_t) + skey->name_len, CompareStdDirKey, this, true); } if (!rc) { if (g_debug & Dbg_Dir) std::cout << "Lookup failed!" << std::endl; return false; } const j_drec_val_t *v = reinterpret_cast(e.val); res.file_id = v->file_id; res.date_added = v->date_added; // v->unk ? // TODO: SIBLING-ID! XF! if (g_debug & Dbg_Dir) std::cout << "Lookup: id = " << res.file_id << std::endl; return true; } bool ApfsDir::ReadFile(void* data, uint64_t inode, uint64_t offs, size_t size) { BTreeEntry e; bool rc; uint8_t *bdata = reinterpret_cast(data); size_t cur_size; uint64_t blk_idx; uint64_t blk_offs; uint64_t extent_size; uint64_t extent_offs; paddr_t extent_paddr; uint64_t extent_crypto_id; while (size > 0) { if (m_vol.isSealed()) { fext_tree_key_t key; const fext_tree_key_t *fext_key = nullptr; const fext_tree_val_t *fext_val = nullptr; key.private_id = inode; key.logical_addr = offs; rc = m_vol.fexttree().Lookup(e, &key, sizeof(key), CompareFextKey, this, false); if (!rc) return false; fext_key = reinterpret_cast(e.key); fext_val = reinterpret_cast(e.val); extent_offs = offs - fext_key->logical_addr; extent_size = fext_val->len_and_flags & J_FILE_EXTENT_LEN_MASK; extent_paddr = fext_val->phys_block_num; extent_crypto_id = 0; /* TODO: Crypto on sealed volumes? Need later beta for that ... */ } else { j_file_extent_key_t key; const j_file_extent_key_t *ext_key = nullptr; const j_file_extent_val_t *ext_val = nullptr; key.hdr.obj_id_and_type = APFS_TYPE_ID(APFS_TYPE_FILE_EXTENT, inode); key.logical_addr = offs; if (g_debug & Dbg_Dir) std::cout << "ReadFile(inode=" << inode << ",offs=" << offs << ",size=" << size << ")" << std::endl; rc = m_fs_tree.Lookup(e, &key, sizeof(key), CompareStdDirKey, this, false); if (!rc) return false; ext_key = reinterpret_cast(e.key); ext_val = reinterpret_cast(e.val); if (g_debug & Dbg_Dir) { std::cout << "FileExtent " << ext_key->hdr.obj_id_and_type << " " << ext_key->logical_addr << " => "; std::cout << ext_val->len_and_flags << " " << ext_val->phys_block_num << " " << ext_val->crypto_id << std::endl; } if (ext_key->hdr.obj_id_and_type != key.hdr.obj_id_and_type) return false; // Remove flags from length member extent_offs = offs - ext_key->logical_addr; extent_size = ext_val->len_and_flags & J_FILE_EXTENT_LEN_MASK; extent_paddr = ext_val->phys_block_num; extent_crypto_id = ext_val->crypto_id; } blk_idx = extent_offs >> m_blksize_sh; blk_offs = extent_offs & m_blksize_mask_lo; cur_size = size; if ((extent_offs + cur_size) > extent_size) cur_size = extent_size - extent_offs; if (cur_size == 0) break; if (extent_paddr != 0) { if (blk_offs == 0 && cur_size > m_blksize) cur_size &= m_blksize_mask_hi; if (blk_offs == 0 && (cur_size & m_blksize_mask_lo) == 0) { if (g_debug & Dbg_Dir) std::cout << "Full read blk " << extent_paddr + blk_idx << " cnt " << (cur_size >> m_blksize_sh) << std::endl; m_vol.ReadBlocks(bdata, extent_paddr + blk_idx, cur_size >> m_blksize_sh, extent_crypto_id + blk_idx); } else { if (g_debug & Dbg_Dir) std::cout << "Partial read blk " << extent_paddr + blk_idx << " cnt 1" << std::endl; m_vol.ReadBlocks(m_tmp_blk.data(), extent_paddr + blk_idx, 1, extent_crypto_id + blk_idx); if (blk_offs + cur_size > m_blksize) cur_size = m_blksize - blk_offs; if (g_debug & Dbg_Dir) std::cout << "Partial copy off " << blk_offs << " size " << cur_size << std::endl; memcpy(bdata, m_tmp_blk.data() + blk_offs, cur_size); } } else memset(bdata, 0, cur_size); bdata += cur_size; offs += cur_size; size -= cur_size; // printf("ReadFile: offs=%016lX size=%016lX\n", offs, size); } return true; } bool ApfsDir::ListAttributes(std::vector& names, uint64_t inode) { j_inode_key_t skey; const j_xattr_key_t *ekey; BTreeIterator it; BTreeEntry res; bool rc; skey.hdr.obj_id_and_type = APFS_TYPE_ID(APFS_TYPE_INODE, inode); rc = m_fs_tree.GetIterator(it, &skey, sizeof(j_inode_key_t), CompareStdDirKey, this); if (!rc) return false; for (;;) { rc = it.GetEntry(res); if (!rc) break; ekey = reinterpret_cast(res.key); if ((ekey->hdr.obj_id_and_type & OBJ_ID_MASK) != inode) break; if ((ekey->hdr.obj_id_and_type >> OBJ_TYPE_SHIFT) < APFS_TYPE_XATTR) { it.next(); continue; } if ((ekey->hdr.obj_id_and_type >> OBJ_TYPE_SHIFT) > APFS_TYPE_XATTR) break; names.push_back(reinterpret_cast(ekey->name)); it.next(); } return true; } bool ApfsDir::GetAttribute(std::vector& data, uint64_t inode, const char* name) { uint8_t skey_buf[0x500]; j_xattr_key_t *skey = reinterpret_cast(skey_buf); const j_xattr_val_t *attr; const j_xattr_dstream_t *xstm = nullptr; // const uint8_t *adata; BTreeEntry res; bool rc; size_t name_len = strlen(name) + 1; if (name_len > 0x400) return false; skey->hdr.obj_id_and_type = APFS_TYPE_ID(APFS_TYPE_XATTR, inode); skey->name_len = static_cast(name_len); memcpy(skey->name, name, skey->name_len); rc = m_fs_tree.Lookup(res, skey, sizeof(j_xattr_key_t) + skey->name_len, CompareStdDirKey, this, true); if (!rc) return false; attr = reinterpret_cast(res.val); // adata = reinterpret_cast(res.val) + sizeof(APFS_Xattr_Val); if (g_debug & Dbg_Dir) std::cout << "GetAttribute: type=" << attr->flags << std::endl; if (attr->flags & XATTR_DATA_STREAM) { // Attribute contents are stored in a file assert(attr->xdata_len == sizeof(j_xattr_dstream_t)); xstm = reinterpret_cast(attr->xdata); if (g_debug & Dbg_Dir) { std::cout << "Attribute is link:" << std::endl; std::cout << " obj_id : " << xstm->xattr_obj_id << std::endl; std::cout << " size : " << xstm->dstream.size << std::endl; std::cout << " alloced_size : " << xstm->dstream.alloced_size << std::endl; std::cout << " default_crypto_id : " << xstm->dstream.default_crypto_id << std::endl; std::cout << " total_bytes_written : " << xstm->dstream.total_bytes_written << std::endl; std::cout << " total_bytes_read : " << xstm->dstream.total_bytes_read << std::endl; } data.resize(xstm->dstream.alloced_size); ReadFile(data.data(), xstm->xattr_obj_id, 0, data.size()); // Read must be multiple of 4K ... data.resize(xstm->dstream.size); if (g_debug & Dbg_Dir) { size_t dmpsize = 0x40; if (dmpsize > data.size()) dmpsize = data.size(); DumpBuffer(data.data(), dmpsize, "start of attribute content"); } } else if (attr->flags & XATTR_DATA_EMBEDDED) { // Attribute contents are stored in the btree data.assign(attr->xdata, attr->xdata + attr->xdata_len); } return true; } bool ApfsDir::GetAttributeInfo(ApfsDir::XAttr& attr, uint64_t inode, const char* name) { uint8_t skey_buf[0x500]; j_xattr_key_t *skey = reinterpret_cast(skey_buf); const j_xattr_val_t *xv; const j_xattr_dstream_t *xs = nullptr; BTreeEntry res; bool rc; size_t name_len = strlen(name) + 1; if (name_len > 0x400) return false; skey->hdr.obj_id_and_type = APFS_TYPE_ID(APFS_TYPE_XATTR, inode); skey->name_len = static_cast(name_len); memcpy(skey->name, name, skey->name_len); rc = m_fs_tree.Lookup(res, skey, sizeof(j_xattr_key_t) + skey->name_len, CompareStdDirKey, this, true); if (!rc) return false; xv = reinterpret_cast(res.val); attr.flags = xv->flags; attr.xdata_len = xv->xdata_len; if (xv->flags & XATTR_DATA_STREAM) { xs = reinterpret_cast(xv->xdata); attr.xstrm = *xs; } return true; } int ApfsDir::CompareStdDirKey(const void *skey, size_t skey_len, const void *ekey, size_t ekey_len, void *context) { // assert(skey_len == 8); // assert(ekey_len == 8); (void)ekey_len; ApfsDir *dir = reinterpret_cast(context); uint64_t ks = *reinterpret_cast(skey); uint64_t ke = *reinterpret_cast(ekey); // std::cout << std::hex << std::uppercase << std::setfill('0'); ks = (ks << 4) | (ks >> 60); ke = (ke << 4) | (ke >> 60); // std::cout << std::setw(16) << ks << " : " << std::setw(16) << ke << std::endl; if (ke < ks) return -1; if (ke > ks) return 1; if (skey_len > 8) { switch (ks & 0xF) { case APFS_TYPE_DIR_REC: if (dir->m_txt_fmt & 9) { const j_drec_hashed_key_t *s = reinterpret_cast(skey); const j_drec_hashed_key_t *e = reinterpret_cast(ekey); /* TODO: Is this correct? Yes. TODO check _apfs_cstrncmp. */ if ((e->name_len_and_hash & J_DREC_HASH_MASK) < (s->name_len_and_hash & J_DREC_HASH_MASK)) return -1; if ((e->name_len_and_hash & J_DREC_HASH_MASK) > (s->name_len_and_hash & J_DREC_HASH_MASK)) return 1; return apfs_strncmp(e->name, e->name_len_and_hash & J_DREC_LEN_MASK, s->name, s->name_len_and_hash & J_DREC_LEN_MASK); } else { const j_drec_key_t *s = reinterpret_cast(skey); const j_drec_key_t *e = reinterpret_cast(ekey); return apfs_strncmp(e->name, e->name_len, s->name, s->name_len); } break; case APFS_TYPE_FILE_EXTENT: { const j_file_extent_key_t *s = reinterpret_cast(skey); const j_file_extent_key_t *e = reinterpret_cast(ekey); assert(skey_len == sizeof(j_file_extent_key_t)); assert(ekey_len == sizeof(j_file_extent_key_t)); if (e->logical_addr < s->logical_addr) return -1; if (e->logical_addr > s->logical_addr) return 1; } break; case APFS_TYPE_XATTR: { const j_xattr_key_t *s = reinterpret_cast(skey); const j_xattr_key_t *e = reinterpret_cast(ekey); return apfs_strncmp(e->name, e->name_len, s->name, s->name_len); } break; case APFS_TYPE_FILE_INFO: { const j_file_info_key_t *s = reinterpret_cast(skey); const j_file_info_key_t *e = reinterpret_cast(ekey); if (e->info_and_lba < s->info_and_lba) return -1; if (e->info_and_lba > s->info_and_lba) return 1; break; } } } return 0; } int ApfsDir::CompareFextKey(const void* skey, size_t skey_len, const void* ekey, size_t ekey_len, void* context) { const fext_tree_key_t *s = reinterpret_cast(skey); const fext_tree_key_t *e = reinterpret_cast(ekey); if (e->private_id < s->private_id) return -1; if (e->private_id > s->private_id) return 1; if (e->logical_addr < s->logical_addr) return -1; if (e->logical_addr > s->logical_addr) return 1; return 0; }