def __init__(self, name):
# Initialize variables for memory regions and buffers and Semaphore
self.shm_buf = None
self.shm_region = None
self.md_buf = None
self.md_region = None
self.image_lock = None
self.shm_name = name
self.md_name = name + "-meta"
self.image_lock_name = name
# Initialize or retreive metadata memory region
try:
self.md_region = SharedMemory(self.md_name)
self.md_buf = mmap.mmap(self.md_region.fd, sizeof(MD))
self.md_region.close_fd()
except ExistentialError:
self.md_region = SharedMemory(self.md_name,
O_CREAT,
size=sizeof(MD))
self.md_buf = mmap.mmap(self.md_region.fd, self.md_region.size)
self.md_region.close_fd()
# Initialize or retreive Semaphore
try:
self.image_lock = Semaphore(self.image_lock_name, O_CREX)
except ExistentialError:
image_lock = Semaphore(self.image_lock_name, O_CREAT)
image_lock.unlink()
self.image_lock = Semaphore(self.image_lock_name, O_CREX)
self.image_lock.release()
def __init__(self, name):
# Initialize varaibles for memory regions and buffers and Semaphore
self.shm_buf = None
self.shm_region = None
self.value_lock = None
self.shm_name = name
self.value_lock_name = name
# Initialize shared memory buffer
try:
self.shm_region = SharedMemory(self.shm_name)
self.shm_buf = mmap.mmap(self.shm_region.fd, sizeof(c_float))
self.shm_region.close_fd()
except ExistentialError:
self.shm_region = SharedMemory(self.shm_name,
O_CREAT,
size=sizeof(c_float))
self.shm_buf = mmap.mmap(self.shm_region.fd, self.shm_region.size)
self.shm_region.close_fd()
# Initialize or retreive Semaphore
try:
self.value_lock = Semaphore(self.value_lock_name, O_CREX)
except ExistentialError:
value_lock = Semaphore(self.value_lock_name, O_CREAT)
value_lock.unlink()
self.value_lock = Semaphore(self.value_lock_name, O_CREX)
self.value_lock.release()
def __init__(self, name):
self.shm_region = None
logging.info("Writer launched")
self.md_region = SharedMemory(name + '-meta', O_CREAT, size=sizeof(MD))
self.md_buf = mmap.mmap(self.md_region.fd, self.md_region.size)
self.md_region.close_fd()
self.shm_buf = None
self.shm_name = name
self.count = 0
try:
self.sem = Semaphore(name, O_CREX)
except ExistentialError:
sem = Semaphore(name, O_CREAT)
sem.unlink()
self.sem = Semaphore(name, O_CREX)
self.sem.release()
def lock(self, on_create: Callable = default_on_create):
hash = hashlib.sha1(self.path.encode()).hexdigest()
with Semaphore(f"/{hash}-lock", flags=O_CREAT, initial_value=1):
retval = os.path.exists(self._file)
if not retval:
with open(self._file, "w") as f:
f.write("1")
on_create(self.path)
return retval
def _connect(self):
'''
attempt to connect to the shared memory
'''
LOG.info('shmem %s: attempting connect', self._name)
shmem = SharedMemory(self._name)
self._mmap = mmap.mmap(shmem.fd, shmem.size)
shmem.close_fd()
self._lock = Semaphore('/pyspace_%s_lock' % self._name)
LOG.info('shmem %s: connect succeeded', self._name)
def setup_email():
# TODO: Fix this data race! This try/catch is ugly; why is it even
# racing here? Perhaps we need to multiproc + multithread lock
# inside of setup_database to block the check?
with Semaphore("/test-emails", flags=O_CREAT, initial_value=1):
if not os.path.exists(Email.TEST_DIR):
# Create the directory.
os.makedirs(Email.TEST_DIR)
# Cleanup all email files for this test suite.
prefix = Email.email_prefix(suite=True)
files = os.listdir(Email.TEST_DIR)
for file in files:
if file.startswith(prefix):
os.remove(os.path.join(Email.TEST_DIR, file))
def __init__(self, name):
self.shm_buf = None
self.md_buf = None
while not self.md_buf:
try:
print("Waiting for Block Input...")
md_region = SharedMemory(name + '-meta')
self.md_buf = mmap.mmap(md_region.fd, sizeof(MD))
md_region.close_fd()
sleep(1)
except ExistentialError:
sleep(1)
self.shm_name = name
self.sem = Semaphore(name, 0)
def __init__(self, name):
self.shm_buf = None
self.md_buf = None
while not self.md_buf:
try:
# print("Waiting for MetaData shared memory is available.")
md_region = SharedMemory(name + "-meta")
self.md_buf = mmap.mmap(md_region.fd, sizeof(MD))
md_region.close_fd()
# sleep(1)
except ExistentialError:
pass
# sleep(1)
self.shm_name = name
self.sem = Semaphore(name, 0)
def __init__(self, name):
self.shm_buf = None
self.md_buf = None
logging.info("Reader launched")
while not self.md_buf:
try:
logging.warning(
"Waiting for MetaData shared memory is available.")
md_region = SharedMemory(name + '-meta')
self.md_buf = mmap.mmap(md_region.fd, sizeof(MD))
md_region.close_fd()
sleep(1)
except ExistentialError:
sleep(1)
self.shm_name = name
self.sem = Semaphore(name, 0)
def pi(n):
pids = []
unit = n / 10
sem_lock = Semaphore('/pi_sem_lock', flags=posix_ipc.O_CREX, initial_value=1)
memory = Memory('/pi_rw', size=8, flags=posix_ipc.O_CREX)
os.lseek(memory.fd, 0, os.SEEK_SET)
os.write(memory.fd, struct.pack('d', 0.0))
for i in range(10):
mink = unit * i
maxk = mink + unit
pid = os.fork()
if pid > 0:
pids.append(pid)
else:
s = calc_slice(mink, maxk)
sem_lock.acquire()
try:
os.lseek(memory.fd, 0, os.SEEK_SET)
bs = os.read(memory.fd, 8)
cur_val, = struct.unpack('d', bs)
cur_val += s
bs = struct.pack('d', cur_val) # 序列化
os.lseek(memory.fd, 0, os.SEEK_SET)
os.write(memory.fd, bs)
memory.close_fd()
finally:
sem_lock.release()
sys.exit(0)
sums = []
for pid in pids:
os.waitpid(pid, 0)
os.lseek(memory.fd, 0, os.SEEK_SET)
bs = os.read(memory.fd, 8)
sums, = struct.unpack('d', bs)
memory.close_fd()
memory.unlink()
sem_lock.unlink()
return math.sqrt(sums * 8)
def _create(self):
'''
attempt to create and initialize the shared memory
'''
LOG.info('shmem %s: attempting create shmem', self._name)
shmem = SharedMemory(self._name, size=SHMEM_SIZE, flags=O_CREX)
LOG.info('shmem %s: attempting create mmap', self._name)
self._mmap = mmap.mmap(shmem.fd, shmem.size)
shmem.close_fd()
LOG.info('shmem %s: attempting create semaphore', self._name)
self._lock = Semaphore('/pyspace_%s_lock' % self._name, flags=O_CREX)
LOG.info('shmem %s: create succeeded', self._name)
try:
self._initialize()
self._lock.release()
except:
LOG.exception('shmem %s: initialize failed; attempting unlink', self._name)
shmem.unlink()
self._lock.unlink()
raise
# -*- coding: utf-8 -*-
from z3 import *
from ast import *
from utils import *
from posix_ipc import Semaphore, O_CREAT
import os
import sys
import atexit
N_CPUS = 4
## Use semaphore to limit the number of concurrent processes,
## we allow N_CPUS processes running simultaneously.
sem = Semaphore("/fork_sem", O_CREAT, 0o644, N_CPUS)
sem.unlink()
sem.acquire()
def on_exit():
sem.release()
## reap all zombies.
try:
while True:
os.waitpid(0)
except:
pass
log("exit")
atexit.register(on_exit)
def __init__(self, name=None):
self._value = None
self._semaphore = Semaphore(name, flags=O_CREX)
def __init__(self, target_path, args=[]):
global _lock
global _process
global _target_path
global _shm
global _mm
global _ping_sem
global _pong_sem
global _clients
global _next_client_id
if _shm is None:
launch_afl_forkserver = True
else:
launch_afl_forkserver = False
with _lock:
self.client_id = _next_client_id
_next_client_id += 1
if launch_afl_forkserver:
if _process is None:
env = os.environ.copy()
if 'EXTERNAL_AFL_FORKSERVER' not in env:
print("Starting afl-forkserver...")
fd, afl_out_file = tempfile.mkstemp(
suffix='afl_out_file')
os.close(fd)
FNULL = open(os.devnull, 'w')
cmd = [
gym_fuzz1ng.afl_forkserver_path(),
'-f',
afl_out_file,
'--',
target_path,
]
cmd += args
cmd += ['@@']
_process = subprocess.Popen(
cmd,
env=env,
stdout=FNULL,
stderr=subprocess.STDOUT,
)
_target_path = target_path
time.sleep(1)
_shm = SharedMemory(SHARED_MEM_NAME)
_mm = mmap.mmap(_shm.fd, 0)
_ping_sem = Semaphore(SEM_PING_SIGNAL_NAME)
_pong_sem = Semaphore(SEM_PONG_SIGNAL_NAME)
else:
if target_path != _target_path:
raise Exception(
"Concurrent targets is not supported: {} {}".
format(
target_path,
_target_path,
), )
else:
print("Skipping afl-forkserver start.")
_clients[self.client_id] = True
