libappfuse/FuseAppLoop.cc - third_party/android/platform/system/core - Git at Google

 /*
  * Copyright (C) 2016 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 specic language governing permissions and
  * limitations under the License.
  */

 #include "libappfuse/FuseAppLoop.h"

 #include <sys/eventfd.h>
 #include <sys/stat.h>

 #include <android-base/logging.h>
 #include <android-base/unique_fd.h>

 #include "libappfuse/EpollController.h"

 namespace android {
 namespace fuse {

 namespace {

 bool HandleLookUp(FuseAppLoop* loop, FuseBuffer* buffer, FuseAppLoopCallback* callback) {
     // AppFuse does not support directory structure now.
     // It can lookup only files under the mount point.
     if (buffer->request.header.nodeid != FUSE_ROOT_ID) {
         LOG(ERROR) << "Nodeid is not FUSE_ROOT_ID.";
         return loop->ReplySimple(buffer->request.header.unique, -ENOENT);
     }

     // Ensure that the filename ends with 0.
     const size_t filename_length = buffer->request.header.len - sizeof(fuse_in_header);
     if (buffer->request.lookup_name[filename_length - 1] != 0) {
         LOG(ERROR) << "File name does not end with 0.";
         return loop->ReplySimple(buffer->request.header.unique, -ENOENT);
     }

     const uint64_t inode = static_cast<uint64_t>(atol(buffer->request.lookup_name));
     if (inode == 0 || inode == LONG_MAX) {
         LOG(ERROR) << "Invalid filename";
         return loop->ReplySimple(buffer->request.header.unique, -ENOENT);
     }

     callback->OnLookup(buffer->request.header.unique, inode);
     return true;
 }

 bool HandleGetAttr(FuseAppLoop* loop, FuseBuffer* buffer, FuseAppLoopCallback* callback) {
     if (buffer->request.header.nodeid == FUSE_ROOT_ID) {
         return loop->ReplyGetAttr(buffer->request.header.unique, buffer->request.header.nodeid, 0,
                                   S_IFDIR | 0777);
     } else {
         callback->OnGetAttr(buffer->request.header.unique, buffer->request.header.nodeid);
         return true;
     }
 }

 bool HandleRead(FuseAppLoop* loop, FuseBuffer* buffer, FuseAppLoopCallback* callback) {
     if (buffer->request.read_in.size > kFuseMaxRead) {
         return loop->ReplySimple(buffer->request.header.unique, -EINVAL);
     }

     callback->OnRead(buffer->request.header.unique, buffer->request.header.nodeid,
                      buffer->request.read_in.offset, buffer->request.read_in.size);
     return true;
 }

 bool HandleWrite(FuseAppLoop* loop, FuseBuffer* buffer, FuseAppLoopCallback* callback) {
     if (buffer->request.write_in.size > kFuseMaxWrite) {
         return loop->ReplySimple(buffer->request.header.unique, -EINVAL);
     }

     callback->OnWrite(buffer->request.header.unique, buffer->request.header.nodeid,
                       buffer->request.write_in.offset, buffer->request.write_in.size,
                       buffer->request.write_data);
     return true;
 }

 bool HandleMessage(FuseAppLoop* loop, FuseBuffer* buffer, int fd, FuseAppLoopCallback* callback) {
     if (!buffer->request.Read(fd)) {
         return false;
     }

     const uint32_t opcode = buffer->request.header.opcode;
     LOG(VERBOSE) << "Read a fuse packet, opcode=" << opcode;
     switch (opcode) {
         case FUSE_FORGET:
             // Do not reply to FUSE_FORGET.
             return true;

         case FUSE_LOOKUP:
             return HandleLookUp(loop, buffer, callback);

         case FUSE_GETATTR:
             return HandleGetAttr(loop, buffer, callback);

         case FUSE_OPEN:
             callback->OnOpen(buffer->request.header.unique, buffer->request.header.nodeid);
             return true;

         case FUSE_READ:
             return HandleRead(loop, buffer, callback);

         case FUSE_WRITE:
             return HandleWrite(loop, buffer, callback);

         case FUSE_RELEASE:
             callback->OnRelease(buffer->request.header.unique, buffer->request.header.nodeid);
             return true;

         case FUSE_FSYNC:
             callback->OnFsync(buffer->request.header.unique, buffer->request.header.nodeid);
             return true;

         default:
             buffer->HandleNotImpl();
             return buffer->response.Write(fd);
     }
 }

 } // namespace

 FuseAppLoopCallback::~FuseAppLoopCallback() = default;

 FuseAppLoop::FuseAppLoop(base::unique_fd&& fd) : fd_(std::move(fd)) {}

 void FuseAppLoop::Break() {
     const int64_t value = 1;
     if (write(break_fd_, &value, sizeof(value)) == -1) {
         PLOG(ERROR) << "Failed to send a break event";
     }
 }

 bool FuseAppLoop::ReplySimple(uint64_t unique, int32_t result) {
     if (result == -ENOSYS) {
         // We should not return -ENOSYS because the kernel stops delivering FUSE
         // command after receiving -ENOSYS as a result for the command.
         result = -EBADF;
     }
     FuseSimpleResponse response;
     response.Reset(0, result, unique);
     return response.Write(fd_);
 }

 bool FuseAppLoop::ReplyLookup(uint64_t unique, uint64_t inode, int64_t size) {
     FuseSimpleResponse response;
     response.Reset(sizeof(fuse_entry_out), 0, unique);
     response.entry_out.nodeid = inode;
     response.entry_out.attr_valid = 10;
     response.entry_out.entry_valid = 10;
     response.entry_out.attr.ino = inode;
     response.entry_out.attr.mode = S_IFREG | 0777;
     response.entry_out.attr.size = size;
     return response.Write(fd_);
 }

 bool FuseAppLoop::ReplyGetAttr(uint64_t unique, uint64_t inode, int64_t size, int mode) {
     CHECK(mode == (S_IFREG | 0777) || mode == (S_IFDIR | 0777));
     FuseSimpleResponse response;
     response.Reset(sizeof(fuse_attr_out), 0, unique);
     response.attr_out.attr_valid = 10;
     response.attr_out.attr.ino = inode;
     response.attr_out.attr.mode = mode;
     response.attr_out.attr.size = size;
     return response.Write(fd_);
 }

 bool FuseAppLoop::ReplyOpen(uint64_t unique, uint64_t fh) {
     FuseSimpleResponse response;
     response.Reset(sizeof(fuse_open_out), kFuseSuccess, unique);
     response.open_out.fh = fh;
     return response.Write(fd_);
 }

 bool FuseAppLoop::ReplyWrite(uint64_t unique, uint32_t size) {
     CHECK(size <= kFuseMaxWrite);
     FuseSimpleResponse response;
     response.Reset(sizeof(fuse_write_out), kFuseSuccess, unique);
     response.write_out.size = size;
     return response.Write(fd_);
 }

 bool FuseAppLoop::ReplyRead(uint64_t unique, uint32_t size, const void* data) {
     CHECK(size <= kFuseMaxRead);
     FuseSimpleResponse response;
     response.ResetHeader(size, kFuseSuccess, unique);
     return response.WriteWithBody(fd_, sizeof(FuseResponse), data);
 }

 void FuseAppLoop::Start(FuseAppLoopCallback* callback) {
     break_fd_.reset(eventfd(/* initval */ 0, EFD_CLOEXEC));
     if (break_fd_.get() == -1) {
         PLOG(ERROR) << "Failed to open FD for break event";
         return;
     }

     base::unique_fd epoll_fd(epoll_create1(EPOLL_CLOEXEC));
     if (epoll_fd.get() == -1) {
         PLOG(ERROR) << "Failed to open FD for epoll";
         return;
     }

     int last_event;
     int break_event;

     std::unique_ptr<EpollController> epoll_controller(new EpollController(std::move(epoll_fd)));
     if (!epoll_controller->AddFd(fd_, EPOLLIN, &last_event)) {
         return;
     }
     if (!epoll_controller->AddFd(break_fd_, EPOLLIN, &break_event)) {
         return;
     }

     last_event = 0;
     break_event = 0;

     FuseBuffer buffer;
     while (true) {
         if (!epoll_controller->Wait(1)) {
             break;
         }
         last_event = 0;
         *reinterpret_cast<int*>(epoll_controller->events()[0].data.ptr) =
             epoll_controller->events()[0].events;

         if (break_event != 0 || (last_event & ~EPOLLIN) != 0) {
             break;
         }

         if (!HandleMessage(this, &buffer, fd_, callback)) {
             break;
         }
     }

     LOG(VERBOSE) << "FuseAppLoop exit";
 }

 }  // namespace fuse
 }  // namespace android
	/*
	* Copyright (C) 2016 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 specic language governing permissions and
	* limitations under the License.
	*/

	#include "libappfuse/FuseAppLoop.h"

	#include <sys/eventfd.h>
	#include <sys/stat.h>

	#include <android-base/logging.h>
	#include <android-base/unique_fd.h>

	#include "libappfuse/EpollController.h"

	namespace android {
	namespace fuse {

	namespace {

	bool HandleLookUp(FuseAppLoop* loop, FuseBuffer* buffer, FuseAppLoopCallback* callback) {
	// AppFuse does not support directory structure now.
	// It can lookup only files under the mount point.
	if (buffer->request.header.nodeid != FUSE_ROOT_ID) {
	LOG(ERROR) << "Nodeid is not FUSE_ROOT_ID.";
	return loop->ReplySimple(buffer->request.header.unique, -ENOENT);
	}

	// Ensure that the filename ends with 0.
	const size_t filename_length = buffer->request.header.len - sizeof(fuse_in_header);
	if (buffer->request.lookup_name[filename_length - 1] != 0) {
	LOG(ERROR) << "File name does not end with 0.";
	return loop->ReplySimple(buffer->request.header.unique, -ENOENT);
	}

	const uint64_t inode = static_cast<uint64_t>(atol(buffer->request.lookup_name));
	if (inode == 0 \|\| inode == LONG_MAX) {
	LOG(ERROR) << "Invalid filename";
	return loop->ReplySimple(buffer->request.header.unique, -ENOENT);
	}

	callback->OnLookup(buffer->request.header.unique, inode);
	return true;
	}

	bool HandleGetAttr(FuseAppLoop* loop, FuseBuffer* buffer, FuseAppLoopCallback* callback) {
	if (buffer->request.header.nodeid == FUSE_ROOT_ID) {
	return loop->ReplyGetAttr(buffer->request.header.unique, buffer->request.header.nodeid, 0,
	S_IFDIR \| 0777);
	} else {
	callback->OnGetAttr(buffer->request.header.unique, buffer->request.header.nodeid);
	return true;
	}
	}

	bool HandleRead(FuseAppLoop* loop, FuseBuffer* buffer, FuseAppLoopCallback* callback) {
	if (buffer->request.read_in.size > kFuseMaxRead) {
	return loop->ReplySimple(buffer->request.header.unique, -EINVAL);
	}

	callback->OnRead(buffer->request.header.unique, buffer->request.header.nodeid,
	buffer->request.read_in.offset, buffer->request.read_in.size);
	return true;
	}

	bool HandleWrite(FuseAppLoop* loop, FuseBuffer* buffer, FuseAppLoopCallback* callback) {
	if (buffer->request.write_in.size > kFuseMaxWrite) {
	return loop->ReplySimple(buffer->request.header.unique, -EINVAL);
	}

	callback->OnWrite(buffer->request.header.unique, buffer->request.header.nodeid,
	buffer->request.write_in.offset, buffer->request.write_in.size,
	buffer->request.write_data);
	return true;
	}

	bool HandleMessage(FuseAppLoop* loop, FuseBuffer* buffer, int fd, FuseAppLoopCallback* callback) {
	if (!buffer->request.Read(fd)) {
	return false;
	}

	const uint32_t opcode = buffer->request.header.opcode;
	LOG(VERBOSE) << "Read a fuse packet, opcode=" << opcode;
	switch (opcode) {
	case FUSE_FORGET:
	// Do not reply to FUSE_FORGET.
	return true;

	case FUSE_LOOKUP:
	return HandleLookUp(loop, buffer, callback);

	case FUSE_GETATTR:
	return HandleGetAttr(loop, buffer, callback);

	case FUSE_OPEN:
	callback->OnOpen(buffer->request.header.unique, buffer->request.header.nodeid);
	return true;

	case FUSE_READ:
	return HandleRead(loop, buffer, callback);

	case FUSE_WRITE:
	return HandleWrite(loop, buffer, callback);

	case FUSE_RELEASE:
	callback->OnRelease(buffer->request.header.unique, buffer->request.header.nodeid);
	return true;

	case FUSE_FSYNC:
	callback->OnFsync(buffer->request.header.unique, buffer->request.header.nodeid);
	return true;

	default:
	buffer->HandleNotImpl();
	return buffer->response.Write(fd);
	}
	}

	} // namespace

	FuseAppLoopCallback::~FuseAppLoopCallback() = default;

	FuseAppLoop::FuseAppLoop(base::unique_fd&& fd) : fd_(std::move(fd)) {}

	void FuseAppLoop::Break() {
	const int64_t value = 1;
	if (write(break_fd_, &value, sizeof(value)) == -1) {
	PLOG(ERROR) << "Failed to send a break event";
	}
	}

	bool FuseAppLoop::ReplySimple(uint64_t unique, int32_t result) {
	if (result == -ENOSYS) {
	// We should not return -ENOSYS because the kernel stops delivering FUSE
	// command after receiving -ENOSYS as a result for the command.
	result = -EBADF;
	}
	FuseSimpleResponse response;
	response.Reset(0, result, unique);
	return response.Write(fd_);
	}

	bool FuseAppLoop::ReplyLookup(uint64_t unique, uint64_t inode, int64_t size) {
	FuseSimpleResponse response;
	response.Reset(sizeof(fuse_entry_out), 0, unique);
	response.entry_out.nodeid = inode;
	response.entry_out.attr_valid = 10;
	response.entry_out.entry_valid = 10;
	response.entry_out.attr.ino = inode;
	response.entry_out.attr.mode = S_IFREG \| 0777;
	response.entry_out.attr.size = size;
	return response.Write(fd_);
	}

	bool FuseAppLoop::ReplyGetAttr(uint64_t unique, uint64_t inode, int64_t size, int mode) {
	CHECK(mode == (S_IFREG \| 0777) \|\| mode == (S_IFDIR \| 0777));
	FuseSimpleResponse response;
	response.Reset(sizeof(fuse_attr_out), 0, unique);
	response.attr_out.attr_valid = 10;
	response.attr_out.attr.ino = inode;
	response.attr_out.attr.mode = mode;
	response.attr_out.attr.size = size;
	return response.Write(fd_);
	}

	bool FuseAppLoop::ReplyOpen(uint64_t unique, uint64_t fh) {
	FuseSimpleResponse response;
	response.Reset(sizeof(fuse_open_out), kFuseSuccess, unique);
	response.open_out.fh = fh;
	return response.Write(fd_);
	}

	bool FuseAppLoop::ReplyWrite(uint64_t unique, uint32_t size) {
	CHECK(size <= kFuseMaxWrite);
	FuseSimpleResponse response;
	response.Reset(sizeof(fuse_write_out), kFuseSuccess, unique);
	response.write_out.size = size;
	return response.Write(fd_);
	}

	bool FuseAppLoop::ReplyRead(uint64_t unique, uint32_t size, const void* data) {
	CHECK(size <= kFuseMaxRead);
	FuseSimpleResponse response;
	response.ResetHeader(size, kFuseSuccess, unique);
	return response.WriteWithBody(fd_, sizeof(FuseResponse), data);
	}

	void FuseAppLoop::Start(FuseAppLoopCallback* callback) {
	break_fd_.reset(eventfd(/* initval */ 0, EFD_CLOEXEC));
	if (break_fd_.get() == -1) {
	PLOG(ERROR) << "Failed to open FD for break event";
	return;
	}

	base::unique_fd epoll_fd(epoll_create1(EPOLL_CLOEXEC));
	if (epoll_fd.get() == -1) {
	PLOG(ERROR) << "Failed to open FD for epoll";
	return;
	}

	int last_event;
	int break_event;

	std::unique_ptr<EpollController> epoll_controller(new EpollController(std::move(epoll_fd)));
	if (!epoll_controller->AddFd(fd_, EPOLLIN, &last_event)) {
	return;
	}
	if (!epoll_controller->AddFd(break_fd_, EPOLLIN, &break_event)) {
	return;
	}

	last_event = 0;
	break_event = 0;

	FuseBuffer buffer;
	while (true) {
	if (!epoll_controller->Wait(1)) {
	break;
	}
	last_event = 0;
	reinterpret_cast<int>(epoll_controller->events()[0].data.ptr) =
	epoll_controller->events()[0].events;

	if (break_event != 0 \|\| (last_event & ~EPOLLIN) != 0) {
	break;
	}

	if (!HandleMessage(this, &buffer, fd_, callback)) {
	break;
	}
	}

	LOG(VERBOSE) << "FuseAppLoop exit";
	}

	} // namespace fuse
	} // namespace android