tqcq/trrespass
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

feat: format code

Browse Source
This commit is contained in:
tqcq 2024-10-21 01:47:43 +00:00
parent 1dbf12c728
commit c7227f88b6
6 changed files with 583 additions and 557 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
.clang-format Normal file
View File

@ -0,0 +1,78 @@
# Generated from CLion C/C++ Code Style settings
BinPackParameters: false
BasedOnStyle: LLVM
AccessModifierOffset: -4
AlignArrayOfStructures: Left
AlignAfterOpenBracket: Align
AlignConsecutiveAssignments:
Enabled: true
AcrossEmptyLines: true
AcrossComments: false
AlignOperands: DontAlign
AllowAllArgumentsOnNextLine: false
AllowAllConstructorInitializersOnNextLine: false
AllowAllParametersOfDeclarationOnNextLine: false
AllowShortBlocksOnASingleLine: Always
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: All
AllowShortIfStatementsOnASingleLine: true
AllowShortLambdasOnASingleLine: All
AllowShortLoopsOnASingleLine: true
AlwaysBreakTemplateDeclarations: Yes
# 函数和返回类型分两行，方便阅读
AlwaysBreakAfterReturnType: TopLevelDefinitions
BreakBeforeBraces: Custom
BraceWrapping:
AfterCaseLabel: false
AfterClass: false
AfterControlStatement: Never
AfterEnum: false
AfterFunction: true
AfterNamespace: false
AfterUnion: false
BeforeCatch: false
BeforeElse: false
IndentBraces: false
SplitEmptyFunction: false
SplitEmptyRecord: true
BreakBeforeBinaryOperators: NonAssignment
BreakBeforeTernaryOperators: true
BreakConstructorInitializers: BeforeColon
ConstructorInitializerAllOnOneLineOrOnePerLine: true
BreakInheritanceList: BeforeColon
ColumnLimit: 120
CompactNamespaces: false
ContinuationIndentWidth: 4
EmptyLineBeforeAccessModifier: LogicalBlock
SeparateDefinitionBlocks: Always
IndentCaseLabels: false
IndentPPDirectives: None
IndentWidth: 4
KeepEmptyLinesAtTheStartOfBlocks: true
MaxEmptyLinesToKeep: 1
NamespaceIndentation: None
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: false
PointerAlignment: Right
ReflowComments: false
SortIncludes: CaseSensitive
SpaceAfterCStyleCast: true
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: false
SpaceBeforeAssignmentOperators: true
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 0
SpacesInAngles: false
SpacesInCStyleCastParentheses: false
SpacesInContainerLiterals: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
TabWidth: 4
UseTab: Never
PenaltyIndentedWhitespace: 1

10
drama/src/include/rev-mc.h
View File

@ -1,14 +1,12 @@
#include "utils.h"
#include "unistd.h"
#include "utils.h"
typedef struct {
char* v_addr;
uint64_t p_addr;
char *v_addr;
uint64_t p_addr;
} addr_tuple;
//----------------------------------------------------------
// Functions
void rev_mc(size_t sets_cnt, size_t threshold, size_t rounds, size_t m_size, char* o_file, uint64_t flags);
void rev_mc(size_t sets_cnt, size_t threshold, size_t rounds, size_t m_size, char *o_file, uint64_t flags);

99
drama/src/include/utils.h
View File

@ -1,95 +1,82 @@
#pragma once
#pragma once
#include <stdint.h>
#include <stdio.h>
#define BIT(x) (1ULL<<(x))
#define KB(x) ((x)<<10ULL)
#define MB(x) ((x)<<20ULL)
#define GB(x) ((x)<<30ULL)
#define BIT(x) (1ULL << (x))
#define KB(x) ((x) << 10ULL)
#define MB(x) ((x) << 20ULL)
#define GB(x) ((x) << 30ULL)
#define CL_SHIFT 6
#define CL_SIZE 64
#define F_CLEAR 0L
#define F_VERBOSE BIT(0)
#define F_EXPORT BIT(1)
#define F_CLEAR 0L
#define F_VERBOSE BIT(0)
#define F_EXPORT BIT(1)
#define MEM_SHIFT (30L)
#define MEM_MASK 0b11111ULL << MEM_SHIFT
#define F_ALLOC_HUGE BIT(MEM_SHIFT)
#define F_ALLOC_HUGE_1G F_ALLOC_HUGE | BIT(MEM_SHIFT+1)
#define F_ALLOC_HUGE_2M F_ALLOC_HUGE | BIT(MEM_SHIFT+2)
#define F_POPULATE BIT(MEM_SHIFT+3)
#define MEM_SHIFT (30L)
#define MEM_MASK 0b11111ULL << MEM_SHIFT
#define F_ALLOC_HUGE BIT(MEM_SHIFT)
#define F_ALLOC_HUGE_1G F_ALLOC_HUGE | BIT(MEM_SHIFT + 1)
#define F_ALLOC_HUGE_2M F_ALLOC_HUGE | BIT(MEM_SHIFT + 2)
#define F_POPULATE BIT(MEM_SHIFT + 3)
//----------------------------------------------------------
// Static functions
static inline __attribute__((always_inline)) void clflush(volatile void *p)
static inline __attribute__((always_inline)) void
clflush(volatile void *p)
{
asm volatile("clflush (%0)\n"
:: "r" (p) : "memory");
asm volatile("clflush (%0)\n" ::"r"(p) : "memory");
}
static inline __attribute__((always_inline)) void mfence()
static inline __attribute__((always_inline)) void
mfence()
{
asm volatile ("mfence" : : : "memory");
asm volatile("mfence" : : : "memory");
}
static inline __attribute__((always_inline)) void lfence()
static inline __attribute__((always_inline)) void
lfence()
{
asm volatile ("lfence" : : : "memory");
asm volatile("lfence" : : : "memory");
}
static inline __attribute__((always_inline)) uint64_t rdtscp(void)
static inline __attribute__((always_inline)) uint64_t
rdtscp(void)
{
uint64_t lo, hi;
asm volatile("rdtscp\n"
: "=a" (lo), "=d" (hi)
:: "%rcx");
return (hi << 32) | lo;
uint64_t lo, hi;
asm volatile("rdtscp\n" : "=a"(lo), "=d"(hi)::"%rcx");
return (hi << 32) | lo;
}
static inline __attribute__((always_inline)) uint64_t rdtsc(void)
static inline __attribute__((always_inline)) uint64_t
rdtsc(void)
{
uint64_t lo, hi;
asm volatile("rdtsc\n"
: "=a" (lo), "=d" (hi)
:: "%rcx");
return (hi << 32) | lo;
uint64_t lo, hi;
asm volatile("rdtsc\n" : "=a"(lo), "=d"(hi)::"%rcx");
return (hi << 32) | lo;
}
//----------------------------------------------------------
// Memory alloc
typedef struct {
char* buffer;
uint64_t size;
uint64_t flags;
char *buffer;
uint64_t size;
uint64_t flags;
} mem_buff_t;
int alloc_buffer(mem_buff_t *mem);
int alloc_buffer(mem_buff_t* mem);
int free_buffer(mem_buff_t* mem);
int free_buffer(mem_buff_t *mem);
//----------------------------------------------------------
// Helpers
int gt(const void * a, const void * b);
// Helpers
int gt(const void *a, const void *b);
double mean(uint64_t* vals, size_t size);
double mean(uint64_t *vals, size_t size);
uint64_t median(uint64_t* vals, size_t size);
char* bit_string(uint64_t val);
uint64_t median(uint64_t *vals, size_t size);
char *bit_string(uint64_t val);

171
drama/src/main.c
View File

@ -1,134 +1,119 @@
#include "stdio.h"
// #include <x86intrin.h> /* for rdtsc, rdtscp, clflush */
#include <stdint.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <sched.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdbool.h>
#include <getopt.h>
#include <sched.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
#include "utils.h"
#include "rev-mc.h"
#include "utils.h"
#define SETS_std (2*16) // 1rk-1ch
#define ROUNDS_std 1000
#define THRESHOLD_std 340
#define MEM_SIZE_std GB(5L)
#define O_FILE_std "access.csv"
#define SETS_std (2 * 16)// 1rk-1ch
#define ROUNDS_std 1000
#define THRESHOLD_std 340
#define MEM_SIZE_std GB(5L)
#define O_FILE_std "access.csv"
#define FIELDS "base,probe,rounds,time"
//-----------------------------------------------
// GLOBALS
//-----------------------------------------------
void print_usage() {
fprintf(stderr, "[ LOG ] - Usage ./test [-h] [-s sets] [-r rounds] [-t threshold] [-o o_file] [-v] [--mem mem_size]\n");
void
print_usage()
{
fprintf(stderr,
"[ LOG ] - Usage ./test [-h] [-s sets] [-r rounds] [-t threshold] [-o o_file] [-v] [--mem mem_size]\n");
fprintf(stderr, " -h = this help message\n");
fprintf(stderr, " -s sets = number of expected sets (default: %d)\n", SETS_std);
fprintf(stderr, " -r rounds = number of rounds per tuple (default: %d)\n", ROUNDS_std);
fprintf(stderr, " -t threshold = time threshold for conflicts (default: %d)\n", THRESHOLD_std);
fprintf(stderr, " -o o_file = output file for mem profiling (default: %s)\n", O_FILE_std);
fprintf(stderr, " --mem mem_size = allocation size (default: %ld)\n", (uint64_t) MEM_SIZE_std);
fprintf(stderr, " -r rounds = number of rounds per tuple (default: %d)\n",
ROUNDS_std);
fprintf(stderr, " -t threshold = time threshold for conflicts (default: %d)\n",
THRESHOLD_std);
fprintf(stderr, " -o o_file = output file for mem profiling (default: %s)\n",
O_FILE_std);
fprintf(stderr, " --mem mem_size = allocation size (default: %ld)\n",
(uint64_t) MEM_SIZE_std);
fprintf(stderr, " -v = verbose\n\n");
}
//-----------------------------------------------
int main(int argc, char** argv) {
int
main(int argc, char **argv)
{
uint64_t flags = 0ULL;
size_t sets_cnt = SETS_std;
size_t rounds = ROUNDS_std;
size_t m_size = MEM_SIZE_std;
size_t threshold = THRESHOLD_std;
char* o_file = (char*) O_FILE_std;
uint64_t flags = 0ULL;
size_t sets_cnt = SETS_std;
size_t rounds = ROUNDS_std;
size_t m_size = MEM_SIZE_std;
size_t threshold = THRESHOLD_std;
char *o_file = (char *) O_FILE_std;
flags |= F_POPULATE;
if(geteuid() != 0) {
fprintf(stderr, "[ERROR] - You need to run as root to access pagemap!\n");
exit(1);
if (geteuid() != 0) {
fprintf(stderr, "[ERROR] - You need to run as root to access pagemap!\n");
exit(1);
}
while (1) {
int this_option_optind = optind ? optind : 1;
int option_index = 0;
static struct option long_options[] =
{
/* These options set a flag. */
{"mem", required_argument, 0, 0},
{0, 0, 0, 0}
};
int arg = getopt_long (argc, argv, "o:s:r:t:hv",
long_options, &option_index);
int this_option_optind = optind ? optind : 1;
int option_index = 0;
static struct option long_options[] = {
/* These options set a flag. */
{"mem", required_argument, 0, 0},
{0, 0, 0, 0}
};
int arg = getopt_long(argc, argv, "o:s:r:t:hv", long_options, &option_index);
if (arg == -1)
break;
if (arg == -1) break;
switch(arg) {
switch (arg) {
case 0:
switch (option_index) {
case 0:
switch (option_index){
case 0:
m_size = atoi(optarg); // TODO proper parsing of this
break;
default:
break;
}
m_size = atoi(optarg);// TODO proper parsing of this
break;
case 'o':
o_file = (char*) malloc(sizeof(char)*strlen(optarg));
strncpy(o_file, optarg, strlen(optarg));
flags |= F_EXPORT;
break;
case 's':
sets_cnt = atoi(optarg);
break;
case 'r':
rounds = atoi(optarg);
break;
case 't':
threshold = atoi(optarg);
break;
case 'v':
flags |= F_VERBOSE;
break;
case 'h':
default:
print_usage();
return 0;
break;
}
break;
case 'o':
o_file = (char *) malloc(sizeof(char) * strlen(optarg));
strncpy(o_file, optarg, strlen(optarg));
flags |= F_EXPORT;
break;
case 's':
sets_cnt = atoi(optarg);
break;
case 'r':
rounds = atoi(optarg);
break;
case 't':
threshold = atoi(optarg);
break;
case 'v':
flags |= F_VERBOSE;
break;
case 'h':
default:
print_usage();
return 0;
}
}
rev_mc(sets_cnt, threshold, rounds, m_size, o_file, flags);
return 0;
}
/*I'm refactoring the set struct to add also timing in there. */

667
drama/src/rev-mc.c
View File

@ -19,24 +19,21 @@
#define BOOL_XOR(a, b) ((a) != (b))
#define O_HEADER "base,probe,time\n"
#define ALIGN_TO(X, Y) \
((X) & (~((1LL << (Y)) - 1LL))) // Mask out the lower Y bits
#define LS_BITMASK(X) ((1LL << (X)) - 1LL) // Mask only the lower X bits
#define ALIGN_TO(X, Y) ((X) & (~((1LL << (Y)) - 1LL)))// Mask out the lower Y bits
#define LS_BITMASK(X) ((1LL << (X)) - 1LL) // Mask only the lower X bits
#define SET_SIZE 40 // elements per set
#define SET_SIZE 40// elements per set
#define VALID_THRESH 0.75f
#define SET_THRESH 0.95f
#define BITSET_SIZE 256 // bitset used to exploit bitwise operations
#define BITSET_SIZE 256// bitset used to exploit bitwise operations
#define ROW_SET_CNT 5
// from
// https://stackoverflow.com/questions/1644868/define-macro-for-debug-printing-in-c
#define verbose_printerr(fmt, ...) \
do { \
if (flags & F_VERBOSE) { \
fprintf(stderr, fmt, ##__VA_ARGS__); \
} \
} while (0)
#define verbose_printerr(fmt, ...) \
do { \
if (flags & F_VERBOSE) { fprintf(stderr, fmt, ##__VA_ARGS__); } \
} while (0)
typedef std::vector<addr_tuple> set_t;
@ -52,200 +49,198 @@ void verify_sets(std::vector<set_t> &sets, uint64_t threshold, size_t rounds);
#pragma push_options
#pragma optimize("O0")
static std::vector<uint64_t> time_vals;
uint64_t time_tuple(volatile char *a1, volatile char *a2, size_t rounds) {
// uint64_t* time_vals = (uint64_t*) calloc(rounds, sizeof(uint64_t));
if (rounds > time_vals.size())
time_vals.resize(rounds);
uint64_t
time_tuple(volatile char *a1, volatile char *a2, size_t rounds)
{
uint64_t t0;
sched_yield();
for (size_t i = 0; i < rounds; i++) {
mfence();
t0 = rdtscp();
*a1;
*a2;
time_vals[i] = rdtscp() - t0;
lfence();
clflush(a1);
clflush(a2);
}
// uint64_t* time_vals = (uint64_t*) calloc(rounds, sizeof(uint64_t));
if (rounds > time_vals.size()) time_vals.resize(rounds);
uint64_t mdn = median(time_vals.data(), rounds);
// free(time_vals);
return mdn;
uint64_t t0;
sched_yield();
for (size_t i = 0; i < rounds; i++) {
mfence();
t0 = rdtscp();
*a1;
*a2;
time_vals[i] = rdtscp() - t0;
lfence();
clflush(a1);
clflush(a2);
}
uint64_t mdn = median(time_vals.data(), rounds);
// free(time_vals);
return mdn;
}
#pragma pop_options
//----------------------------------------------------------
char *get_rnd_addr(char *base, size_t m_size, size_t align) {
return (char *)ALIGN_TO((uint64_t)base, (uint64_t)align) +
ALIGN_TO(rand() % m_size, (uint64_t)align);
char *
get_rnd_addr(char *base, size_t m_size, size_t align)
{
return (char *) ALIGN_TO((uint64_t) base, (uint64_t) align) + ALIGN_TO(rand() % m_size, (uint64_t) align);
}
//----------------------------------------------------------
uint64_t get_pfn(uint64_t entry) { return ((entry) & 0x3fffffffffffff); }
//----------------------------------------------------------
uint64_t get_phys_addr(uint64_t v_addr) {
uint64_t entry;
uint64_t offset = (v_addr / 4096) * sizeof(entry);
uint64_t pfn;
int fd = open("/proc/self/pagemap", O_RDONLY);
assert(fd >= 0);
int bytes_read = pread(fd, &entry, sizeof(entry), offset);
close(fd);
assert(bytes_read == 8);
assert(entry & (1ULL << 63));
pfn = get_pfn(entry);
assert(pfn != 0 && "pfn is zero !!!!!");
return (pfn * 4096) | (v_addr & 4095);
uint64_t
get_pfn(uint64_t entry)
{
return ((entry) & 0x3fffffffffffff);
}
//----------------------------------------------------------
addr_tuple gen_addr_tuple(char *v_addr) {
return (addr_tuple){v_addr, get_phys_addr((uint64_t)v_addr)};
uint64_t
get_phys_addr(uint64_t v_addr)
{
uint64_t entry;
uint64_t offset = (v_addr / 4096) * sizeof(entry);
uint64_t pfn;
int fd = open("/proc/self/pagemap", O_RDONLY);
assert(fd >= 0);
int bytes_read = pread(fd, &entry, sizeof(entry), offset);
close(fd);
assert(bytes_read == 8);
assert(entry & (1ULL << 63));
pfn = get_pfn(entry);
assert(pfn != 0 && "pfn is zero !!!!!");
return (pfn * 4096) | (v_addr & 4095);
}
//----------------------------------------------------------
addr_tuple
gen_addr_tuple(char *v_addr)
{
return (addr_tuple){v_addr, get_phys_addr((uint64_t) v_addr)};
}
//----------------------------------------------------------
// https://www.cs.umd.edu/~gasarch/TOPICS/factoring/fastgauss.pdf
// gaussian elimination in GF2
std::vector<uint64_t> reduce_masks(std::vector<uint64_t> masks) {
std::vector<uint64_t>
reduce_masks(std::vector<uint64_t> masks)
{
size_t height, width, height_t, width_t;
size_t height, width, height_t, width_t;
height = masks.size();
width = 0;
for (auto m : masks) {
uint64_t max_one = 64 - __builtin_clzl(m);
width = (max_one > width) ? max_one : width;
}
height_t = width;
width_t = height;
std::vector<std::vector<bool>> mtx(height, std::vector<bool>(width));
std::vector<std::vector<bool>> mtx_t(height_t, std::vector<bool>(width_t));
std::vector<uint64_t> filtered_masks;
for (size_t i = 0; i < height; i++) {
for (size_t j = 0; j < width; j++) {
mtx[i][width - j - 1] = (masks[i] & (1ULL << (j)));
height = masks.size();
width = 0;
for (auto m : masks) {
uint64_t max_one = 64 - __builtin_clzl(m);
width = (max_one > width) ? max_one : width;
}
}
for (size_t i = 0; i < height; i++) {
for (size_t j = 0; j < width; j++) {
mtx_t[j][i] = mtx[i][j];
height_t = width;
width_t = height;
std::vector<std::vector<bool>> mtx(height, std::vector<bool>(width));
std::vector<std::vector<bool>> mtx_t(height_t, std::vector<bool>(width_t));
std::vector<uint64_t> filtered_masks;
for (size_t i = 0; i < height; i++) {
for (size_t j = 0; j < width; j++) { mtx[i][width - j - 1] = (masks[i] & (1ULL << (j))); }
}
}
int64_t pvt_col = 0;
for (size_t i = 0; i < height; i++) {
for (size_t j = 0; j < width; j++) { mtx_t[j][i] = mtx[i][j]; }
}
while (pvt_col < width_t) {
for (uint64_t row = 0; row < height_t; row++) {
if (mtx_t[row][pvt_col]) {
filtered_masks.push_back(masks[pvt_col]);
for (size_t c = 0; c < width_t; c++) {
if (c == pvt_col)
continue;
if (!(mtx_t[row][c]))
continue;
int64_t pvt_col = 0;
// column sum
for (size_t r = 0; r < height_t; r++) {
mtx_t[r][c] = BOOL_XOR(mtx_t[r][c], mtx_t[r][pvt_col]);
}
while (pvt_col < width_t) {
for (uint64_t row = 0; row < height_t; row++) {
if (mtx_t[row][pvt_col]) {
filtered_masks.push_back(masks[pvt_col]);
for (size_t c = 0; c < width_t; c++) {
if (c == pvt_col) continue;
if (!(mtx_t[row][c])) continue;
// column sum
for (size_t r = 0; r < height_t; r++) { mtx_t[r][c] = BOOL_XOR(mtx_t[r][c], mtx_t[r][pvt_col]); }
}
break;
}
}
break;
}
pvt_col++;
}
pvt_col++;
}
return filtered_masks;
return filtered_masks;
}
//----------------------------------------------------------
// from https://graphics.stanford.edu/~seander/bithacks.html#NextBitPermutation
uint64_t next_bit_permutation(uint64_t v) {
uint64_t t = v | (v - 1);
return (t + 1) | (((~t & -~t) - 1) >> (__builtin_ctzl(v) + 1));
uint64_t
next_bit_permutation(uint64_t v)
{
uint64_t t = v | (v - 1);
return (t + 1) | (((~t & -~t) - 1) >> (__builtin_ctzl(v) + 1));
}
//----------------------------------------------------------
std::vector<uint64_t> find_functions(std::vector<set_t> sets,
size_t max_fn_bits, size_t msb,
uint64_t flags) {
std::vector<uint64_t>
find_functions(std::vector<set_t> sets, size_t max_fn_bits, size_t msb, uint64_t flags)
{
std::vector<uint64_t> masks;
verbose_printerr("~~~~~~~~~~ Candidate functions ~~~~~~~~~~\n");
std::vector<uint64_t> masks;
verbose_printerr("~~~~~~~~~~ Candidate functions ~~~~~~~~~~\n");
for (size_t bits = 1L; bits <= max_fn_bits; bits++) {
uint64_t fn_mask =
((1L << (bits)) -
1); // avoid the first 6 bits since they are the cacheline bits
uint64_t last_mask = (fn_mask << (msb - bits));
fn_mask <<= CL_SHIFT;
verbose_printerr("[ LOG ] - #Bits: %ld \n", bits);
while (fn_mask != last_mask) {
if (fn_mask & LS_BITMASK(6)) {
fn_mask = next_bit_permutation(fn_mask);
continue;
}
for (size_t idx = 0; idx < sets.size(); idx++) {
set_t curr_set = sets[idx];
size_t inner_cnt = 0;
for (size_t i = 1; i < curr_set.size(); i++) {
uint64_t res_base = __builtin_parityl(curr_set[0].p_addr & fn_mask);
uint64_t res_probe = __builtin_parityl(curr_set[i].p_addr & fn_mask);
if (res_base != res_probe) {
goto next_mask;
}
for (size_t bits = 1L; bits <= max_fn_bits; bits++) {
uint64_t fn_mask = ((1L << (bits)) - 1);// avoid the first 6 bits since they are the cacheline bits
uint64_t last_mask = (fn_mask << (msb - bits));
fn_mask <<= CL_SHIFT;
verbose_printerr("[ LOG ] - #Bits: %ld \n", bits);
while (fn_mask != last_mask) {
if (fn_mask & LS_BITMASK(6)) {
fn_mask = next_bit_permutation(fn_mask);
continue;
}
for (size_t idx = 0; idx < sets.size(); idx++) {
set_t curr_set = sets[idx];
size_t inner_cnt = 0;
for (size_t i = 1; i < curr_set.size(); i++) {
uint64_t res_base = __builtin_parityl(curr_set[0].p_addr & fn_mask);
uint64_t res_probe = __builtin_parityl(curr_set[i].p_addr & fn_mask);
if (res_base != res_probe) { goto next_mask; }
}
}
verbose_printerr("\t Candidate: 0x%0lx \t\t bits: %s\n", fn_mask, bit_string(fn_mask));
masks.push_back(fn_mask);
next_mask:
fn_mask = next_bit_permutation(fn_mask);
}
}
verbose_printerr("\t Candidate: 0x%0lx \t\t bits: %s\n", fn_mask,
bit_string(fn_mask));
masks.push_back(fn_mask);
next_mask:
fn_mask = next_bit_permutation(fn_mask);
}
}
verbose_printerr("~~~~~~~~~~ Found Functions ~~~~~~~~~~\n");
masks = reduce_masks(masks);
if (flags & F_VERBOSE) {
for (auto m : masks) {
fprintf(stderr, "\t Valid Function: 0x%0lx \t\t bits: %s\n", m,
bit_string(m));
verbose_printerr("~~~~~~~~~~ Found Functions ~~~~~~~~~~\n");
masks = reduce_masks(masks);
if (flags & F_VERBOSE) {
for (auto m : masks) { fprintf(stderr, "\t Valid Function: 0x%0lx \t\t bits: %s\n", m, bit_string(m)); }
}
}
for (auto m : masks) {
fprintf(stdout, "0x%lx\n", m);
}
return masks;
for (auto m : masks) { fprintf(stdout, "0x%lx\n", m); }
return masks;
}
std::vector<int> find_set_bits(uint64_t val) {
std::vector<int> set_bits;
for (int i = 0; i < 64; i++) {
if (!(val & (1ULL << i)))
continue;
std::vector<int>
find_set_bits(uint64_t val)
{
std::vector<int> set_bits;
for (int i = 0; i < 64; i++) {
if (!(val & (1ULL << i))) continue;
set_bits.push_back(i);
}
return set_bits;
set_bits.push_back(i);
}
return set_bits;
}
//----------------------------------------------------------
std::vector<uint8_t> get_dram_fn(uint64_t addr,
std::vector<uint64_t> fn_masks) {
std::vector<uint8_t> addr_dram;
for (auto fn : fn_masks) {
addr_dram.push_back(__builtin_parityl(addr & fn));
}
return addr_dram;
std::vector<uint8_t>
get_dram_fn(uint64_t addr, std::vector<uint64_t> fn_masks)
{
std::vector<uint8_t> addr_dram;
for (auto fn : fn_masks) { addr_dram.push_back(__builtin_parityl(addr & fn)); }
return addr_dram;
}
//----------------------------------------------------------
@ -254,168 +249,155 @@ It currently finds some of the interesting bits for the row addressing.
@TODO still need to figure out which bits are used for the row addressing and
which are from the bank selection. This is currently done manually
*/
uint64_t find_row_mask(std::vector<set_t> &sets, std::vector<uint64_t> fn_masks,
mem_buff_t mem, uint64_t threshold, uint64_t flags) {
uint64_t
find_row_mask(std::vector<set_t> &sets,
std::vector<uint64_t> fn_masks,
mem_buff_t mem,
uint64_t threshold,
uint64_t flags)
{
addr_tuple base_addr = gen_addr_tuple(get_rnd_addr(mem.buffer, mem.size, 0));
std::vector<set_t> same_row_sets;
addr_tuple base_addr = gen_addr_tuple(get_rnd_addr(mem.buffer, mem.size, 0));
std::vector<set_t> same_row_sets;
verbose_printerr("~~~~~~~~~~ Looking for row bits ~~~~~~~~~~\n");
verbose_printerr("~~~~~~~~~~ Looking for row bits ~~~~~~~~~~\n");
for (int i = 0; i < 2; i++) {
verbose_printerr("[LOG] - Set #%d\n", i);
addr_tuple base_addr = sets[i][0];
std::vector<uint8_t> base_dram =
get_dram_fn((uint64_t)base_addr.p_addr, fn_masks);
same_row_sets.push_back({base_addr});
uint64_t cnt = 0;
while (cnt < ROW_SET_CNT) {
for (int i = 0; i < 2; i++) {
verbose_printerr("[LOG] - Set #%d\n", i);
addr_tuple base_addr = sets[i][0];
std::vector<uint8_t> base_dram = get_dram_fn((uint64_t) base_addr.p_addr, fn_masks);
same_row_sets.push_back({base_addr});
uint64_t cnt = 0;
while (cnt < ROW_SET_CNT) {
addr_tuple tmp = gen_addr_tuple(get_rnd_addr(mem.buffer, mem.size, 0));
if (get_dram_fn((uint64_t)tmp.p_addr, fn_masks) != base_dram)
continue;
addr_tuple tmp = gen_addr_tuple(get_rnd_addr(mem.buffer, mem.size, 0));
if (get_dram_fn((uint64_t) tmp.p_addr, fn_masks) != base_dram) continue;
uint64_t time = time_tuple((volatile char *)base_addr.v_addr,
(volatile char *)tmp.v_addr, 1000);
uint64_t time = time_tuple((volatile char *) base_addr.v_addr, (volatile char *) tmp.v_addr, 1000);
if (time > threshold)
continue;
if (time > threshold) continue;
verbose_printerr("[LOG] - %lx - %lx\t Time: %ld <== GOTCHA\n",
base_addr.p_addr, tmp.p_addr, time);
verbose_printerr("[LOG] - %lx - %lx\t Time: %ld <== GOTCHA\n", base_addr.p_addr, tmp.p_addr, time);
same_row_sets[i].push_back(tmp);
cnt++;
}
}
uint64_t row_mask = LS_BITMASK(16); // use 16 bits for the row
uint64_t last_mask = (row_mask << (40 - 16));
row_mask <<=
CL_SHIFT; // skip the lowest 6 bits since they're used for CL addressing
while (row_mask < last_mask) {
if (row_mask & LS_BITMASK(CL_SHIFT)) {
row_mask = next_bit_permutation(row_mask);
continue;
}
for (auto addr_pool : same_row_sets) {
addr_tuple base_addr = addr_pool[0];
for (int i = 1; i < addr_pool.size(); i++) {
addr_tuple tmp = addr_pool[i];
if ((tmp.p_addr & row_mask) != (base_addr.p_addr & row_mask)) {
goto next_mask;
same_row_sets[i].push_back(tmp);
cnt++;
}
}
}
break;
uint64_t row_mask = LS_BITMASK(16);// use 16 bits for the row
uint64_t last_mask = (row_mask << (40 - 16));
row_mask <<= CL_SHIFT;// skip the lowest 6 bits since they're used for CL addressing
next_mask:
row_mask = next_bit_permutation(row_mask);
}
while (row_mask < last_mask) {
if (row_mask & LS_BITMASK(CL_SHIFT)) {
row_mask = next_bit_permutation(row_mask);
continue;
}
// super hackish way to recover the real row mask
for (auto m : fn_masks) {
uint64_t lsb = (1 << (__builtin_ctzl(m) + 1));
if (lsb & row_mask) {
row_mask ^= (1 << __builtin_ctzl(m));
for (auto addr_pool : same_row_sets) {
addr_tuple base_addr = addr_pool[0];
for (int i = 1; i < addr_pool.size(); i++) {
addr_tuple tmp = addr_pool[i];
if ((tmp.p_addr & row_mask) != (base_addr.p_addr & row_mask)) { goto next_mask; }
}
}
break;
next_mask:
row_mask = next_bit_permutation(row_mask);
}
}
verbose_printerr("[LOG] - Row mask: 0x%0lx \t\t bits: %s\n", row_mask,
bit_string(row_mask));
printf("0x%lx\n", row_mask);
return row_mask;
// super hackish way to recover the real row mask
for (auto m : fn_masks) {
uint64_t lsb = (1 << (__builtin_ctzl(m) + 1));
if (lsb & row_mask) { row_mask ^= (1 << __builtin_ctzl(m)); }
}
verbose_printerr("[LOG] - Row mask: 0x%0lx \t\t bits: %s\n", row_mask, bit_string(row_mask));
printf("0x%lx\n", row_mask);
return row_mask;
}
//----------------------------------------------------------
void rev_mc(size_t sets_cnt, size_t threshold, size_t rounds, size_t m_size,
char *o_file, uint64_t flags) {
void
rev_mc(size_t sets_cnt, size_t threshold, size_t rounds, size_t m_size, char *o_file, uint64_t flags)
{
time_t t;
time_t t;
int o_fd = 0;
int huge_fd = 0;
std::vector<set_t> sets;
// std::vector<char*> used_addr;
std::set<char *> used_addr;
std::vector<uint64_t> fn_masks;
int o_fd = 0;
int huge_fd = 0;
std::vector<set_t> sets;
// std::vector<char*> used_addr;
std::set<char *> used_addr;
std::vector<uint64_t> fn_masks;
srand((unsigned)time(&t));
srand((unsigned) time(&t));
if (flags & F_EXPORT) {
if (o_file == NULL) {
fprintf(stderr, "[ERROR] - Missing export file name\n");
exit(1);
if (flags & F_EXPORT) {
if (o_file == NULL) {
fprintf(stderr, "[ERROR] - Missing export file name\n");
exit(1);
}
if ((o_fd = open(o_file, O_CREAT | O_RDWR, 0644)) == -1) {
perror("[ERROR] - Unable to create export file");
exit(1);
}
dprintf(o_fd, O_HEADER);
}
if ((o_fd = open(o_file, O_CREAT | O_RDWR, 0644)) == -1) {
perror("[ERROR] - Unable to create export file");
exit(1);
mem_buff_t mem = {
.buffer = NULL,
.size = m_size,
.flags = flags,
};
alloc_buffer(&mem);
while (!found_enough(sets, sets_cnt, SET_SIZE)) {
char *rnd_addr = get_rnd_addr(mem.buffer, mem.size, CL_SHIFT);
if (is_in(rnd_addr, used_addr)) continue;
// used_addr.push_back(rnd_addr);
used_addr.insert(rnd_addr);
addr_tuple tp = gen_addr_tuple(rnd_addr);
bool found_set = false;
for (size_t idx = 0; idx < sets.size(); idx++) {
uint64_t time = 0;
addr_tuple tmp = sets[idx][0];
time = time_tuple((volatile char *) tmp.v_addr, (volatile char *) tp.v_addr, rounds);
if (flags & F_EXPORT) { dprintf(o_fd, "%lx,%lx,%ld\n", (uint64_t) tp.v_addr, (uint64_t) tmp.v_addr, time); }
if (time > threshold) {
verbose_printerr("[LOG] - [%ld] Set: %03ld -\t %lx - %lx\t Time: %ld\n", used_addr.size(), idx,
tp.p_addr, tmp.p_addr, time);
sets[idx].push_back(tp);
found_set = true;
break;
}
}
if (!found_set) {
sets.push_back({tp});
verbose_printerr("[LOG] - Set: %03ld -\t %p "
" <== NEW!!\n",
sets.size(), tp.v_addr);
}
}
dprintf(o_fd, O_HEADER);
}
mem_buff_t mem = {
.buffer = NULL,
.size = m_size,
.flags = flags,
};
alloc_buffer(&mem);
while (!found_enough(sets, sets_cnt, SET_SIZE)) {
char *rnd_addr = get_rnd_addr(mem.buffer, mem.size, CL_SHIFT);
if (is_in(rnd_addr, used_addr))
continue;
// used_addr.push_back(rnd_addr);
used_addr.insert(rnd_addr);
addr_tuple tp = gen_addr_tuple(rnd_addr);
bool found_set = false;
for (size_t idx = 0; idx < sets.size(); idx++) {
uint64_t time = 0;
addr_tuple tmp = sets[idx][0];
time = time_tuple((volatile char *)tmp.v_addr, (volatile char *)tp.v_addr,
rounds);
if (flags & F_EXPORT) {
dprintf(o_fd, "%lx,%lx,%ld\n", (uint64_t)tp.v_addr,
(uint64_t)tmp.v_addr, time);
}
if (time > threshold) {
verbose_printerr("[LOG] - [%ld] Set: %03ld -\t %lx - %lx\t Time: %ld\n",
used_addr.size(), idx, tp.p_addr, tmp.p_addr, time);
sets[idx].push_back(tp);
found_set = true;
break;
}
}
if (!found_set) {
sets.push_back({tp});
verbose_printerr("[LOG] - Set: %03ld -\t %p "
" <== NEW!!\n",
sets.size(), tp.v_addr);
}
}
filter_sets(sets, SET_SIZE);
filter_sets(sets, SET_SIZE);
#ifdef DEBUG_SETS
fprintf(stderr,
"[ LOG ] - Cleansing sets. This may take a while... stay put\n");
verify_sets(sets, threshold, rounds);
fprintf(stderr, "[ LOG ] - Done\n");
fprintf(stderr, "[ LOG ] - Cleansing sets. This may take a while... stay put\n");
verify_sets(sets, threshold, rounds);
fprintf(stderr, "[ LOG ] - Done\n");
#endif
if (flags & F_VERBOSE) {
print_sets(sets);
}
if (flags & F_VERBOSE) { print_sets(sets); }
fn_masks = find_functions(sets, 6, 30, flags);
uint64_t row_mask = find_row_mask(sets, fn_masks, mem, threshold, flags);
fn_masks = find_functions(sets, 6, 30, flags);
uint64_t row_mask = find_row_mask(sets, fn_masks, mem, threshold, flags);
free_buffer(&mem);
free_buffer(&mem);
}
// Fin.
@ -423,87 +405,86 @@ void rev_mc(size_t sets_cnt, size_t threshold, size_t rounds, size_t m_size,
//----------------------------------------------------------
// Helpers
bool is_in(char *val, std::set<char *> arr) {
return arr.find(val) != arr.end();
bool
is_in(char *val, std::set<char *> arr)
{
return arr.find(val) != arr.end();
}
bool is_in(char *val, std::vector<char *> arr) {
for (auto v : arr) {
if (val == v) {
return true;
bool
is_in(char *val, std::vector<char *> arr)
{
for (auto v : arr) {
if (val == v) { return true; }
}
}
return false;
return false;
}
//----------------------------------------------------------
bool found_enough(std::vector<set_t> sets, uint64_t set_cnt, size_t set_size) {
bool
found_enough(std::vector<set_t> sets, uint64_t set_cnt, size_t set_size)
{
size_t found_sets = 0;
size_t found_sets = 0;
for (int i = 0; i < sets.size(); i++) {
set_t curr_set = sets[i];
if (curr_set.size() > set_size) {
found_sets += 1;
for (int i = 0; i < sets.size(); i++) {
set_t curr_set = sets[i];
if (curr_set.size() > set_size) { found_sets += 1; }
}
}
if (found_sets > set_cnt) {
fprintf(
stderr,
"[ERROR] - Found too many sets. Is %ld the correct number of sets?\n",
set_cnt);
exit(1);
}
if (found_sets > set_cnt) {
fprintf(stderr, "[ERROR] - Found too many sets. Is %ld the correct number of sets?\n", set_cnt);
exit(1);
}
return (found_sets >= (set_cnt * SET_THRESH)) ? true : false;
return (found_sets >= (set_cnt * SET_THRESH)) ? true : false;
}
void filter_sets(std::vector<set_t> &sets, size_t set_size) {
void
filter_sets(std::vector<set_t> &sets, size_t set_size)
{
for (auto s = sets.begin(); s < sets.end(); s++) {
if (s->size() < set_size) {
sets.erase(s);
s -= 1;
for (auto s = sets.begin(); s < sets.end(); s++) {
if (s->size() < set_size) {
sets.erase(s);
s -= 1;
}
}
}
}
void print_sets(std::vector<set_t> sets) {
void
print_sets(std::vector<set_t> sets)
{
for (int idx = 0; idx < sets.size(); idx++) {
fprintf(stderr, "[LOG] - Set: %d\tSize: %ld\n", idx, sets[idx].size());
for (auto tmp : sets[idx]) {
fprintf(stderr, "\tv_addr:%p - p_addr:%p\n", tmp.v_addr,
(void *)tmp.p_addr);
for (int idx = 0; idx < sets.size(); idx++) {
fprintf(stderr, "[LOG] - Set: %d\tSize: %ld\n", idx, sets[idx].size());
for (auto tmp : sets[idx]) { fprintf(stderr, "\tv_addr:%p - p_addr:%p\n", tmp.v_addr, (void *) tmp.p_addr); }
}
}
}
#ifdef DEBUG_SETS
void verify_sets(std::vector<set_t> &sets, uint64_t threshold, size_t rounds) {
void
verify_sets(std::vector<set_t> &sets, uint64_t threshold, size_t rounds)
{
for (auto s : sets) {
// test every address against all the addresses in the set
for (auto tp_base = s.begin(); tp_base < s.end(); tp_base++) {
uint64_t conflicts = 0;
for (auto tp_probe = s.begin(); tp_probe < s.end(); tp_probe++) {
if (tp_base == tp_probe)
continue;
for (auto s : sets) {
// test every address against all the addresses in the set
for (auto tp_base = s.begin(); tp_base < s.end(); tp_base++) {
uint64_t conflicts = 0;
for (auto tp_probe = s.begin(); tp_probe < s.end(); tp_probe++) {
if (tp_base == tp_probe) continue;
uint64_t time = time_tuple((volatile char *)tp_base->v_addr,
(volatile char *)tp_probe->v_addr, rounds);
if (time > threshold) {
conflicts += 1;
uint64_t time =
time_tuple((volatile char *) tp_base->v_addr, (volatile char *) tp_probe->v_addr, rounds);
if (time > threshold) { conflicts += 1; }
}
if (!(conflicts > VALID_THRESH * s.size())) {
fprintf(stderr, "[ LOG ] - Removing: %p\n", tp_base->v_addr);
s.erase(tp_base--);// reset the iterator
}
}
}
if (!(conflicts > VALID_THRESH * s.size())) {
fprintf(stderr, "[ LOG ] - Removing: %p\n", tp_base->v_addr);
s.erase(tp_base--); // reset the iterator
}
}
}
}
#endif

115
drama/src/utils.c
View File

@ -1,87 +1,84 @@
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <assert.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include "utils.h"
//-----------------------------------------------
// Memory alloc
int alloc_buffer(mem_buff_t* mem) {
if (mem->buffer != NULL) {
fprintf(stderr, "[ERROR] - Memory already allocated\n");
}
int
alloc_buffer(mem_buff_t *mem)
{
if (mem->buffer != NULL) { fprintf(stderr, "[ERROR] - Memory already allocated\n"); }
uint64_t alloc_flags = MAP_PRIVATE | MAP_POPULATE | MAP_ANONYMOUS;
uint64_t alloc_flags = MAP_PRIVATE | MAP_POPULATE | MAP_ANONYMOUS;
mem->buffer = (char*) mmap(NULL, mem->size, PROT_READ | PROT_WRITE, alloc_flags, -1, 0);
if (mem->buffer == MAP_FAILED) {
perror("[ERROR] - mmap() failed");
exit(1);
}
if (mem->flags & F_VERBOSE) {
fprintf(stderr, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
fprintf(stderr, "[ MEM ] - Buffer: %p\n", mem->buffer);
fprintf(stderr, "[ MEM ] - Size: %ld\n", mem->size);
fprintf(stderr, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
}
return 0;
mem->buffer = (char *) mmap(NULL, mem->size, PROT_READ | PROT_WRITE, alloc_flags, -1, 0);
if (mem->buffer == MAP_FAILED) {
perror("[ERROR] - mmap() failed");
exit(1);
}
if (mem->flags & F_VERBOSE) {
fprintf(stderr, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
fprintf(stderr, "[ MEM ] - Buffer: %p\n", mem->buffer);
fprintf(stderr, "[ MEM ] - Size: %ld\n", mem->size);
fprintf(stderr, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
}
return 0;
}
int free_buffer(mem_buff_t* mem) {
return munmap(mem->buffer, mem->size);
int
free_buffer(mem_buff_t *mem)
{
return munmap(mem->buffer, mem->size);
}
//-----------------------------------------------
// Helpers
double mean(uint64_t* vals, size_t size) {
uint64_t avg = 0;
for (size_t i = 0; i < size; i++) {
avg += vals[i];
}
return ((double)avg) / size;
double
mean(uint64_t *vals, size_t size)
{
uint64_t avg = 0;
for (size_t i = 0; i < size; i++) { avg += vals[i]; }
return ((double) avg) / size;
}
int gt(const void * a, const void * b) {
return ( *(int*)a - *(int*)b );
int
gt(const void *a, const void *b)
{
return (*(int *) a - *(int *) b);
}
uint64_t median(uint64_t* vals, size_t size) {
qsort(vals, size, sizeof(uint64_t), gt);
return ((size%2)==0) ? vals[size/2] : (vals[(size_t)size/2]+vals[((size_t)size/2+1)])/2;
uint64_t
median(uint64_t *vals, size_t size)
{
qsort(vals, size, sizeof(uint64_t), gt);
return ((size % 2) == 0) ? vals[size / 2] : (vals[(size_t) size / 2] + vals[((size_t) size / 2 + 1)]) / 2;
}
char *
bit_string(uint64_t val)
{
static char bit_str[256];
char itoa_str[8];
strcpy(bit_str, "");
for (int shift = 0; shift < 64; shift++) {
if ((val >> shift) & 1) {
if (strcmp(bit_str, "") != 0) { strcat(bit_str, "+ "); }
sprintf(itoa_str, "%d ", shift);
strcat(bit_str, itoa_str);
}
}
char* bit_string(uint64_t val) {
static char bit_str[256];
char itoa_str[8];
strcpy(bit_str, "");
for (int shift = 0; shift < 64; shift++) {
if ((val >> shift) & 1) {
if (strcmp(bit_str, "") != 0) {
strcat(bit_str, "+ ");
}
sprintf(itoa_str, "%d ", shift);
strcat(bit_str, itoa_str);
}
}
return bit_str;
return bit_str;
}