/*
**
** Copyright 2017, 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 "perfprofd_binder.h"

#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <memory>
#include <mutex>
#include <string>
#include <thread>

#include <inttypes.h>
#include <unistd.h>

#include <android-base/logging.h>
#include <android-base/stringprintf.h>
#include <android-base/strings.h>
#include <binder/BinderService.h>
#include <binder/IResultReceiver.h>
#include <binder/Status.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
#include <utils/String16.h>
#include <utils/String8.h>
#include <utils/Vector.h>

#include "android/os/BnPerfProfd.h"
#include "perfprofd_config.pb.h"
#include "perfprofd_record.pb.h"

#include "config.h"
#include "configreader.h"
#include "perfprofdcore.h"
#include "perfprofd_threaded_handler.h"

namespace android {
namespace perfprofd {
namespace binder {

namespace {

using Status = ::android::binder::Status;

class PerfProfdNativeService : public BinderService<PerfProfdNativeService>,
                               public ::android::os::BnPerfProfd,
                               public ThreadedHandler {
 public:
  static status_t start();
  static int Main();

  static char const* getServiceName() { return "perfprofd"; }

  status_t dump(int fd, const Vector<String16> &args) override;

  Status startProfiling(int32_t collectionInterval,
                        int32_t iterations,
                        int32_t process,
                        int32_t samplingPeriod,
                        int32_t samplingFrequency,
                        int32_t sampleDuration,
                        bool stackProfile,
                        bool useElfSymbolizer,
                        bool sendToDropbox) override;
  Status startProfilingString(const String16& config) override;
  Status startProfilingProtobuf(const std::vector<uint8_t>& config_proto) override;

  Status stopProfiling() override;

  // Override onTransact so we can handle shellCommand.
  status_t onTransact(uint32_t _aidl_code,
                      const Parcel& _aidl_data,
                      Parcel* _aidl_reply,
                      uint32_t _aidl_flags = 0) override;

 private:
  status_t shellCommand(int /*in*/, int out, int err, Vector<String16>& args);

  template <typename ProtoLoaderFn> Status StartProfilingProtobuf(ProtoLoaderFn fn);
  Status StartProfilingProtobufFd(int fd);
};

status_t PerfProfdNativeService::start() {
  IPCThreadState::self()->disableBackgroundScheduling(true);
  status_t ret = BinderService<PerfProfdNativeService>::publish();
  if (ret != android::OK) {
    return ret;
  }
  sp<ProcessState> ps(ProcessState::self());
  ps->startThreadPool();
  ps->giveThreadPoolName();
  return android::OK;
}

status_t PerfProfdNativeService::dump(int fd, const Vector<String16> &args) {
  auto out = std::fstream(base::StringPrintf("/proc/self/fd/%d", fd));
  auto print_config = [&out](bool is_profiling, const Config* config) {
    if (is_profiling) {
      out << "Profiling with config: " << ConfigReader::ConfigToString(*config);
    } else {
      out << "Not actively profiling.";
    }
  };
  RunOnConfig(print_config);
  out << std::endl;

  return NO_ERROR;
}

Status PerfProfdNativeService::startProfiling(int32_t collectionInterval,
                                              int32_t iterations,
                                              int32_t process,
                                              int32_t samplingPeriod,
                                              int32_t samplingFrequency,
                                              int32_t sampleDuration,
                                              bool stackProfile,
                                              bool useElfSymbolizer,
                                              bool sendToDropbox) {
  auto config_fn = [&](ThreadedConfig& config) {
    config = ThreadedConfig();  // Reset to a default config.

    if (collectionInterval >= 0) {
      config.collection_interval_in_s = collectionInterval;
    }
    if (iterations >= 0) {
      config.main_loop_iterations = iterations;
    }
    if (process >= 0) {
      config.process = process;
    }
    if (samplingPeriod > 0) {
      config.sampling_period = samplingPeriod;
    }
    if (samplingFrequency > 0) {
      config.sampling_frequency = samplingFrequency;
    }
    if (sampleDuration > 0) {
      config.sample_duration_in_s = sampleDuration;
    }
    config.stack_profile = stackProfile;
    config.use_elf_symbolizer = useElfSymbolizer;
    config.send_to_dropbox = sendToDropbox;
  };
  std::string error_msg;
  if (!StartProfiling(config_fn, &error_msg)) {
    return Status::fromExceptionCode(1, error_msg.c_str());
  }
  return Status::ok();
}
Status PerfProfdNativeService::startProfilingString(const String16& config) {
  ConfigReader reader;
  std::string error_msg;
  // Split configuration along colon.
  std::vector<std::string> args = base::Split(String8(config).string(), ":");
  for (auto& arg : args) {
    if (!reader.Read(arg, /* fail_on_error */ true, &error_msg)) {
      std::string tmp = base::StringPrintf("Could not parse %s: %s",
                                           arg.c_str(),
                                           error_msg.c_str());
      return Status::fromExceptionCode(1, tmp.c_str());
    }
  }
  auto config_fn = [&](ThreadedConfig& config) {
    config = ThreadedConfig();  // Reset to a default config.
    reader.FillConfig(&config);
  };
  if (!StartProfiling(config_fn, &error_msg)) {
    return Status::fromExceptionCode(1, error_msg.c_str());
  }
  return Status::ok();
}
Status PerfProfdNativeService::startProfilingProtobuf(const std::vector<uint8_t>& config_proto) {
  auto proto_loader_fn = [&config_proto](ProfilingConfig& proto_config) {
    return proto_config.ParseFromArray(config_proto.data(), config_proto.size());
  };
  return StartProfilingProtobuf(proto_loader_fn);
}

template <typename ProtoLoaderFn>
Status PerfProfdNativeService::StartProfilingProtobuf(ProtoLoaderFn fn) {
  ProfilingConfig proto_config;
  if (!fn(proto_config)) {
    return binder::Status::fromExceptionCode(2, "Could not read protobuf");
  }
  auto config_fn = [&proto_config](ThreadedConfig& config) {
    config = ThreadedConfig();  // Reset to a default config.
    ConfigReader::ProtoToConfig(proto_config, &config);
  };
  std::string error_msg;
  if (!StartProfiling(config_fn, &error_msg)) {
    return Status::fromExceptionCode(1, error_msg.c_str());
  }
  return Status::ok();
}

Status PerfProfdNativeService::StartProfilingProtobufFd(int fd) {
  auto proto_loader_fn = [fd](ProfilingConfig& proto_config) {
    struct IstreamCopyingInputStream : public google::protobuf::io::CopyingInputStream {
      IstreamCopyingInputStream(int fd_in)
                : stream(base::StringPrintf("/proc/self/fd/%d", fd_in),
                         std::ios::binary | std::ios::in) {
      }

      int Read(void* buffer, int size) override {
        stream.read(reinterpret_cast<char*>(buffer), size);
        size_t count = stream.gcount();
        if (count > 0) {
          return count;
        }
        return -1;
      }

      std::ifstream stream;
    };
    std::unique_ptr<IstreamCopyingInputStream> is(new IstreamCopyingInputStream(fd));
    std::unique_ptr<google::protobuf::io::CopyingInputStreamAdaptor> is_adaptor(
        new google::protobuf::io::CopyingInputStreamAdaptor(is.get()));
    return proto_config.ParseFromZeroCopyStream(is_adaptor.get());
  };
  return StartProfilingProtobuf(proto_loader_fn);
}

Status PerfProfdNativeService::stopProfiling() {
  std::string error_msg;
  if (!StopProfiling(&error_msg)) {
    Status::fromExceptionCode(1, error_msg.c_str());
  }
  return Status::ok();
}

status_t PerfProfdNativeService::shellCommand(int in,
                                              int out,
                                              int err_fd,
                                              Vector<String16>& args) {
  if (android::base::kEnableDChecks) {
    LOG(VERBOSE) << "Perfprofd::shellCommand";

    for (size_t i = 0, n = args.size(); i < n; i++) {
      LOG(VERBOSE) << "  arg[" << i << "]: '" << String8(args[i]).string() << "'";
    }
  }

  auto err_str = std::fstream(base::StringPrintf("/proc/self/fd/%d", err_fd));

  if (args.size() >= 1) {
    if (args[0] == String16("dump")) {
      dump(out, args);
      return OK;
    } else if (args[0] == String16("startProfiling")) {
      ConfigReader reader;
      for (size_t i = 1; i < args.size(); ++i) {
        std::string error_msg;
        if (!reader.Read(String8(args[i]).string(), /* fail_on_error */ true, &error_msg)) {
          err_str << "Could not parse '" << String8(args[i]).string() << "': " << error_msg
                  << std::endl;
          return BAD_VALUE;
        }
      }
      auto config_fn = [&](ThreadedConfig& config) {
        config = ThreadedConfig();  // Reset to a default config.
        reader.FillConfig(&config);
      };
      std::string error_msg;
      if (!StartProfiling(config_fn, &error_msg)) {
        err_str << error_msg << std::endl;
        return UNKNOWN_ERROR;
      }
      return OK;
    } else if (args[0] == String16("startProfilingProto")) {
      if (args.size() < 2) {
        return BAD_VALUE;
      }
      int fd = -1;
      if (args[1] == String16("-")) {
        fd = in;
      } else {
        // TODO: Implement reading from disk?
      }
      if (fd < 0) {
        err_str << "Bad file descriptor " << args[1] << std::endl;
        return BAD_VALUE;
      }
      binder::Status status = StartProfilingProtobufFd(fd);
      if (status.isOk()) {
        return OK;
      } else {
        err_str << status.toString8() << std::endl;
        return UNKNOWN_ERROR;
      }
    } else if (args[0] == String16("stopProfiling")) {
      Status status = stopProfiling();
      if (status.isOk()) {
        return OK;
      } else {
        err_str << status.toString8() << std::endl;
        return UNKNOWN_ERROR;
      }
    }
  }
  return BAD_VALUE;
}

status_t PerfProfdNativeService::onTransact(uint32_t _aidl_code,
                                            const Parcel& _aidl_data,
                                            Parcel* _aidl_reply,
                                            uint32_t _aidl_flags) {
  switch (_aidl_code) {
    case IBinder::SHELL_COMMAND_TRANSACTION: {
      int in = _aidl_data.readFileDescriptor();
      int out = _aidl_data.readFileDescriptor();
      int err = _aidl_data.readFileDescriptor();
      int argc = _aidl_data.readInt32();
      Vector<String16> args;
      for (int i = 0; i < argc && _aidl_data.dataAvail() > 0; i++) {
        args.add(_aidl_data.readString16());
      }
      sp<IBinder> unusedCallback;
      sp<IResultReceiver> resultReceiver;
      status_t status;
      if ((status = _aidl_data.readNullableStrongBinder(&unusedCallback)) != OK)
        return status;
      if ((status = _aidl_data.readNullableStrongBinder(&resultReceiver)) != OK)
        return status;
      status = shellCommand(in, out, err, args);
      if (resultReceiver != nullptr) {
        resultReceiver->send(status);
      }
      return OK;
    }

    default:
      return ::android::os::BnPerfProfd::onTransact(
          _aidl_code, _aidl_data, _aidl_reply, _aidl_flags);
  }
}

}  // namespace

int Main() {
  {
    struct DummyConfig : public Config {
      void Sleep(size_t seconds) override {}
      bool IsProfilingEnabled() const override { return false; }
    };
    DummyConfig config;
    GlobalInit(config.perf_path);
  }

  android::status_t ret;
  if ((ret = PerfProfdNativeService::start()) != android::OK) {
    LOG(ERROR) << "Unable to start InstalldNativeService: %d" << ret;
    exit(1);
  }

  android::IPCThreadState::self()->joinThreadPool();

  LOG(INFO) << "Exiting perfprofd";
  return 0;
}

}  // namespace binder
}  // namespace perfprofd
}  // namespace android