blob: a8f99e23cb7bf50d488f64955d7b64577367db96 [file] [log] [blame]
// Copyright 2019 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "MemFd.hpp"
#include "../Debug.hpp"
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <sys/mman.h>
#include <unistd.h>
#ifndef MFD_CLOEXEC
#define MFD_CLOEXEC 0x0001U
#endif
#if __aarch64__
#define __NR_memfd_create 279
#elif __arm__
#define __NR_memfd_create 279
#elif __powerpc64__
#define __NR_memfd_create 360
#elif __i386__
#define __NR_memfd_create 356
#elif __x86_64__
#define __NR_memfd_create 319
#endif /* __NR_memfd_create__ */
LinuxMemFd::~LinuxMemFd()
{
close();
}
void LinuxMemFd::importFd(int fd)
{
close();
fd_ = fd;
}
int LinuxMemFd::exportFd() const
{
if (fd_ < 0)
{
return fd_;
}
// Duplicate file descriptor while setting the clo-on-exec flag (Linux specific).
return ::fcntl(fd_, F_DUPFD_CLOEXEC, 0);
}
bool LinuxMemFd::allocate(const char* name, size_t size)
{
close();
#ifndef __NR_memfd_create
TRACE("memfd_create() not supported on this system!");
return false;
#else
// In the event of no system call this returns -1 with errno set
// as ENOSYS.
fd_ = syscall(__NR_memfd_create, name, MFD_CLOEXEC);
if (fd_ < 0)
{
TRACE("memfd_create() returned %d: %s", errno, strerror(errno));
return false;
}
// Ensure there is enough space.
if (size > 0 && ::ftruncate(fd_, size) < 0)
{
TRACE("ftruncate() %lld returned %d: %s", (long long)size, errno, strerror(errno));
close();
return false;
}
#endif
return true;
}
void LinuxMemFd::close()
{
if (fd_ >= 0)
{
// WARNING: Never retry on close() failure, even with EINTR, see
// https://lwn.net/Articles/576478/ for example.
int ret = ::close(fd_);
if (ret < 0) {
TRACE("LinuxMemFd::close() failed with: %s", strerror(errno));
assert(false);
}
fd_ = -1;
}
}
void* LinuxMemFd::mapReadWrite(size_t offset, size_t size)
{
void* addr = ::mmap(nullptr, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd_,
static_cast<off_t>(offset));
return (addr == MAP_FAILED) ? nullptr : addr;
}
bool LinuxMemFd::unmap(void* addr, size_t size)
{
return ::munmap(addr, size) == 0;
}