blob: 32d5f383e790e7f09c1e47ccd048daf55b1bad38 [file] [log] [blame]
/*
* Copyright (C) 2018 The Android Open Source Project
*
* 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 "libdm/loop_control.h"
#include <fcntl.h>
#include <linux/loop.h>
#include <stdint.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <unistd.h>
#include <android-base/logging.h>
#include <android-base/stringprintf.h>
#include <android-base/unique_fd.h>
#include "utility.h"
namespace android {
namespace dm {
LoopControl::LoopControl() : control_fd_(-1) {
control_fd_.reset(TEMP_FAILURE_RETRY(open(kLoopControlDevice, O_RDWR | O_CLOEXEC)));
if (control_fd_ < 0) {
PLOG(ERROR) << "Failed to open loop-control";
}
}
bool LoopControl::Attach(int file_fd, const std::chrono::milliseconds& timeout_ms,
std::string* loopdev) const {
auto start_time = std::chrono::steady_clock::now();
auto condition = [&]() -> WaitResult {
if (!FindFreeLoopDevice(loopdev)) {
LOG(ERROR) << "Failed to attach, no free loop devices";
return WaitResult::Fail;
}
auto now = std::chrono::steady_clock::now();
auto time_elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - start_time);
if (!WaitForFile(*loopdev, timeout_ms - time_elapsed)) {
LOG(ERROR) << "Timed out waiting for path: " << *loopdev;
return WaitResult::Fail;
}
android::base::unique_fd loop_fd(
TEMP_FAILURE_RETRY(open(loopdev->c_str(), O_RDWR | O_CLOEXEC)));
if (loop_fd < 0) {
PLOG(ERROR) << "Failed to open: " << *loopdev;
return WaitResult::Fail;
}
if (int rc = ioctl(loop_fd, LOOP_SET_FD, file_fd); rc == 0) {
return WaitResult::Done;
}
if (errno != EBUSY) {
PLOG(ERROR) << "Failed LOOP_SET_FD";
return WaitResult::Fail;
}
return WaitResult::Wait;
};
if (!WaitForCondition(condition, timeout_ms)) {
LOG(ERROR) << "Timed out trying to acquire a loop device";
return false;
}
return true;
}
bool LoopControl::Detach(const std::string& loopdev) const {
if (loopdev.empty()) {
LOG(ERROR) << "Must provide a loop device";
return false;
}
android::base::unique_fd loop_fd(TEMP_FAILURE_RETRY(open(loopdev.c_str(), O_RDWR | O_CLOEXEC)));
if (loop_fd < 0) {
PLOG(ERROR) << "Failed to open: " << loopdev;
return false;
}
int rc = ioctl(loop_fd, LOOP_CLR_FD, 0);
if (rc) {
PLOG(ERROR) << "Failed LOOP_CLR_FD for '" << loopdev << "'";
return false;
}
return true;
}
bool LoopControl::FindFreeLoopDevice(std::string* loopdev) const {
int rc = ioctl(control_fd_, LOOP_CTL_GET_FREE);
if (rc < 0) {
PLOG(ERROR) << "Failed to get free loop device";
return false;
}
// Ueventd on android creates all loop devices as /dev/block/loopX
// The total number of available devices is determined by 'loop.max_part'
// kernel command line argument.
*loopdev = ::android::base::StringPrintf("/dev/block/loop%d", rc);
return true;
}
bool LoopControl::EnableDirectIo(int fd) {
#if !defined(LOOP_SET_BLOCK_SIZE)
static constexpr int LOOP_SET_BLOCK_SIZE = 0x4C09;
#endif
#if !defined(LOOP_SET_DIRECT_IO)
static constexpr int LOOP_SET_DIRECT_IO = 0x4C08;
#endif
// Note: the block size has to be >= the logical block size of the underlying
// block device, *not* the filesystem block size.
if (ioctl(fd, LOOP_SET_BLOCK_SIZE, 4096)) {
PLOG(ERROR) << "Could not set loop device block size";
return false;
}
if (ioctl(fd, LOOP_SET_DIRECT_IO, 1)) {
PLOG(ERROR) << "Could not set loop direct IO";
return false;
}
return true;
}
bool LoopControl::SetAutoClearStatus(int fd) {
struct loop_info64 info = {};
info.lo_flags |= LO_FLAGS_AUTOCLEAR;
if (ioctl(fd, LOOP_SET_STATUS64, &info)) {
return false;
}
return true;
}
LoopDevice::LoopDevice(android::base::borrowed_fd fd, const std::chrono::milliseconds& timeout_ms,
bool auto_close)
: fd_(fd), owned_fd_(-1) {
if (auto_close) {
owned_fd_.reset(fd.get());
}
Init(timeout_ms);
}
LoopDevice::LoopDevice(const std::string& path, const std::chrono::milliseconds& timeout_ms)
: fd_(-1), owned_fd_(-1) {
owned_fd_.reset(open(path.c_str(), O_RDWR | O_CLOEXEC));
if (owned_fd_ == -1) {
PLOG(ERROR) << "open failed for " << path;
return;
}
fd_ = owned_fd_;
Init(timeout_ms);
}
LoopDevice::~LoopDevice() {
if (valid()) {
control_.Detach(device_);
}
}
void LoopDevice::Init(const std::chrono::milliseconds& timeout_ms) {
valid_ = control_.Attach(fd_.get(), timeout_ms, &device_);
}
} // namespace dm
} // namespace android