Method _read_async

src/client/Client.cc:11834–11966

}

int Client::_read_async(Fh *f, uint64_t off, uint64_t len, bufferlist *bl,
			Context *onfinish)
{
  ceph_assert(ceph_mutex_is_locked_by_me(client_lock));

  const auto& conf = cct->_conf;
  Inode *in = f->inode.get();
  std::unique_ptr<Context> io_finish = nullptr;
  C_SaferCond *io_finish_cond = nullptr;

  ldout(cct, 10) << __func__ << " " << *in << " " << off << "~" << len << dendl;
  
  uint64_t read_start;
  uint64_t read_len;

  auto effective_size = in->effective_size();
  if (off + len > effective_size) {
    len = effective_size - off;
  }

#if defined(__linux__)
  FSCryptFDataDencRef fscrypt_denc;
  fscrypt->prepare_data_read(in->fscrypt_ctx,
                             &in->fscrypt_key_validator,
                             off, len, in->size,
                             &read_start, &read_len,
                             &fscrypt_denc);
#else
  read_start = off;
  read_len = len;
#endif

  // get Fc cap ref before commencing read
  get_cap_ref(in, CEPH_CAP_FILE_CACHE);

  if (onfinish != nullptr) {
    io_finish.reset(new C_Read_Async_Finisher(this, onfinish, f, in, bl,
                                              f->pos, off, len,
#if defined(__linux__)
                                              fscrypt_denc,
#endif
					      read_start, read_len));
  }

  // trim read based on file size?
  if ((off >= effective_size) || (len == 0)) {
    // read is requested at the EOF or the read len is zero, therefore release
    // Fc cap first before proceeding further
    put_cap_ref(in, CEPH_CAP_FILE_CACHE);

    // If not async, immediate return of 0 bytes
    if (onfinish == nullptr) {
      return 0;
    }

    // Release C_Read_Async_Finisher from managed pointer, we need to complete
    // immediately. The C_Read_Async_Finisher is safely handled and won't be
    // abandoned.