[ceph.git] / ceph / src / messages / MClientRequest.h

// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- 
// vim: ts=8 sw=2 smarttab
/*
 * Ceph - scalable distributed file system
 *
 * Copyright (C) 2004-2006 Sage Weil <sage@newdream.net>
 *
 * This is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License version 2.1, as published by the Free Software 
 * Foundation.  See file COPYING.
 * 
 */


#ifndef CEPH_MCLIENTREQUEST_H
#define CEPH_MCLIENTREQUEST_H

/**
 *
 * MClientRequest - container for a client METADATA request.  created/sent by clients.  
 *    can be forwarded around between MDS's.
 *
 *   int client - the originating client
 *   long tid   - transaction id, unique among requests for that client.  probably just a counter!
 *                -> the MDS passes the Request to the Reply constructor, so this always matches.
 *  
 *   int op - the metadata op code.  MDS_OP_RENAME, etc.
 *   int caller_uid, _gid - guess
 * 
 * fixed size arguments are in a union.
 * there's also a string argument, for e.g. symlink().
 *  
 */

#include <string_view>

#include "msg/Message.h"
#include "include/filepath.h"
#include "mds/mdstypes.h"
#include "include/ceph_features.h"

#include <sys/types.h>
#include <utime.h>
#include <sys/stat.h>
#include <fcntl.h>


// metadata ops.

class MClientRequest : public SafeMessage {
private:
  static constexpr int HEAD_VERSION = 4;
  static constexpr int COMPAT_VERSION = 1;

public:
  mutable struct ceph_mds_request_head head; /* XXX HACK! */
  utime_t stamp;

  struct Release {
    mutable ceph_mds_request_release item;
    string dname;

    Release() : item(), dname() {}
    Release(const ceph_mds_request_release& rel, string name) :
      item(rel), dname(name) {}

    void encode(bufferlist& bl) const {
      using ceph::encode;
      item.dname_len = dname.length();
      encode(item, bl);
      encode_nohead(dname, bl);
    }
    void decode(bufferlist::const_iterator& bl) {
      using ceph::decode;
      decode(item, bl);
      decode_nohead(item.dname_len, dname, bl);
    }
  };
  mutable vector<Release> releases; /* XXX HACK! */

  // path arguments
  filepath path, path2;
  vector<uint64_t> gid_list;

  /* XXX HACK */
  mutable bool queued_for_replay = false;

protected:
  // cons
  MClientRequest()
    : SafeMessage(CEPH_MSG_CLIENT_REQUEST, HEAD_VERSION, COMPAT_VERSION) {}
  MClientRequest(int op)
    : SafeMessage(CEPH_MSG_CLIENT_REQUEST, HEAD_VERSION, COMPAT_VERSION) {
    memset(&head, 0, sizeof(head));
    head.op = op;
  }
  ~MClientRequest() override {}

public:
  void set_mdsmap_epoch(epoch_t e) { head.mdsmap_epoch = e; }
  epoch_t get_mdsmap_epoch() const { return head.mdsmap_epoch; }
  epoch_t get_osdmap_epoch() const {
    ceph_assert(head.op == CEPH_MDS_OP_SETXATTR);
    if (header.version >= 3)
      return head.args.setxattr.osdmap_epoch;
    else
      return 0;
  }
  void set_osdmap_epoch(epoch_t e) {
    ceph_assert(head.op == CEPH_MDS_OP_SETXATTR);
    head.args.setxattr.osdmap_epoch = e;
  }

  metareqid_t get_reqid() const {
    // FIXME: for now, assume clients always have 1 incarnation
    return metareqid_t(get_orig_source(), header.tid); 
  }

  /*bool open_file_mode_is_readonly() {
    return file_mode_is_readonly(ceph_flags_to_mode(head.args.open.flags));
    }*/
  bool may_write() const {
    return
      (head.op & CEPH_MDS_OP_WRITE) || 
      (head.op == CEPH_MDS_OP_OPEN && (head.args.open.flags & (O_CREAT|O_TRUNC)));
  }

  int get_flags() const {
    return head.flags;
  }
  bool is_replay() const {
    return get_flags() & CEPH_MDS_FLAG_REPLAY;
  }
  bool is_async() const {
    return get_flags() & CEPH_MDS_FLAG_ASYNC;
  }

  // normal fields
  void set_stamp(utime_t t) { stamp = t; }
  void set_oldest_client_tid(ceph_tid_t t) { head.oldest_client_tid = t; }
  void inc_num_fwd() { head.num_fwd = head.num_fwd + 1; }
  void set_retry_attempt(int a) { head.num_retry = a; }
  void set_filepath(const filepath& fp) { path = fp; }
  void set_filepath2(const filepath& fp) { path2 = fp; }
  void set_string2(const char *s) { path2.set_path(std::string_view(s), 0); }
  void set_caller_uid(unsigned u) { head.caller_uid = u; }
  void set_caller_gid(unsigned g) { head.caller_gid = g; }
  void set_gid_list(int count, const gid_t *gids) {
    gid_list.reserve(count);
    for (int i = 0; i < count; ++i) {
      gid_list.push_back(gids[i]);
    }
  }
  void set_dentry_wanted() {
    head.flags = head.flags | CEPH_MDS_FLAG_WANT_DENTRY;
  }
  void set_replayed_op() {
    head.flags = head.flags | CEPH_MDS_FLAG_REPLAY;
  }
  void set_async_op() {
    head.flags = head.flags | CEPH_MDS_FLAG_ASYNC;
  }

  utime_t get_stamp() const { return stamp; }
  ceph_tid_t get_oldest_client_tid() const { return head.oldest_client_tid; }
  int get_num_fwd() const { return head.num_fwd; }
  int get_retry_attempt() const { return head.num_retry; }
  int get_op() const { return head.op; }
  unsigned get_caller_uid() const { return head.caller_uid; }
  unsigned get_caller_gid() const { return head.caller_gid; }
  const vector<uint64_t>& get_caller_gid_list() const { return gid_list; }

  const string& get_path() const { return path.get_path(); }
  const filepath& get_filepath() const { return path; }
  const string& get_path2() const { return path2.get_path(); }
  const filepath& get_filepath2() const { return path2; }

  int get_dentry_wanted() const { return get_flags() & CEPH_MDS_FLAG_WANT_DENTRY; }

  void mark_queued_for_replay() const { queued_for_replay = true; }
  bool is_queued_for_replay() const { return queued_for_replay; }

  void decode_payload() override {
    auto p = payload.cbegin();

    if (header.version >= 4) {
      decode(head, p);
    } else {
      struct ceph_mds_request_head_legacy old_mds_head;

      decode(old_mds_head, p);
      copy_from_legacy_head(&head, &old_mds_head);
      head.version = 0;

      /* Can't set the btime from legacy struct */
      if (head.op == CEPH_MDS_OP_SETATTR) {
	int localmask = head.args.setattr.mask;

	localmask &= ~CEPH_SETATTR_BTIME;

	head.args.setattr.btime = { init_le32(0), init_le32(0) };
	head.args.setattr.mask = localmask;
      }
    }

    decode(path, p);
    decode(path2, p);
    decode_nohead(head.num_releases, releases, p);
    if (header.version >= 2)
      decode(stamp, p);
    if (header.version >= 4) // epoch 3 was for a ceph_mds_request_args change
      decode(gid_list, p);
  }

  void encode_payload(uint64_t features) override {
    using ceph::encode;
    head.num_releases = releases.size();
    head.version = CEPH_MDS_REQUEST_HEAD_VERSION;

    if (features & CEPH_FEATURE_FS_BTIME) {
      encode(head, payload);
    } else {
      struct ceph_mds_request_head_legacy old_mds_head;

      copy_to_legacy_head(&old_mds_head, &head);
      encode(old_mds_head, payload);
    }

    encode(path, payload);
    encode(path2, payload);
    encode_nohead(releases, payload);
    encode(stamp, payload);
    encode(gid_list, payload);
  }

  std::string_view get_type_name() const override { return "creq"; }
  void print(ostream& out) const override {
    out << "client_request(" << get_orig_source() 
	<< ":" << get_tid() 
	<< " " << ceph_mds_op_name(get_op());
    if (head.op == CEPH_MDS_OP_GETATTR)
      out << " " << ccap_string(head.args.getattr.mask);
    if (head.op == CEPH_MDS_OP_SETATTR) {
      if (head.args.setattr.mask & CEPH_SETATTR_MODE)
	out << " mode=0" << std::oct << head.args.setattr.mode << std::dec;
      if (head.args.setattr.mask & CEPH_SETATTR_UID)
	out << " uid=" << head.args.setattr.uid;
      if (head.args.setattr.mask & CEPH_SETATTR_GID)
	out << " gid=" << head.args.setattr.gid;
      if (head.args.setattr.mask & CEPH_SETATTR_SIZE)
	out << " size=" << head.args.setattr.size;
      if (head.args.setattr.mask & CEPH_SETATTR_MTIME)
	out << " mtime=" << utime_t(head.args.setattr.mtime);
      if (head.args.setattr.mask & CEPH_SETATTR_ATIME)
	out << " atime=" << utime_t(head.args.setattr.atime);
    }
    if (head.op == CEPH_MDS_OP_SETFILELOCK ||
	head.op == CEPH_MDS_OP_GETFILELOCK) {
      out << " rule " << (int)head.args.filelock_change.rule
	  << ", type " << (int)head.args.filelock_change.type
	  << ", owner " << head.args.filelock_change.owner
	  << ", pid " << head.args.filelock_change.pid
	  << ", start " << head.args.filelock_change.start
	  << ", length " << head.args.filelock_change.length
	  << ", wait " << (int)head.args.filelock_change.wait;
    }
    //if (!get_filepath().empty()) 
    out << " " << get_filepath();
    if (!get_filepath2().empty())
      out << " " << get_filepath2();
    if (stamp != utime_t())
      out << " " << stamp;
    if (head.num_retry)
      out << " RETRY=" << (int)head.num_retry;
    if (is_async())
      out << " ASYNC";
    if (is_replay())
      out << " REPLAY";
    if (queued_for_replay)
      out << " QUEUED_FOR_REPLAY";
    out << " caller_uid=" << head.caller_uid
	<< ", caller_gid=" << head.caller_gid
	<< '{';
    for (auto i = gid_list.begin(); i != gid_list.end(); ++i)
      out << *i << ',';
    out << '}'
	<< ")";
  }
private:
  template<class T, typename... Args>
  friend boost::intrusive_ptr<T> ceph::make_message(Args&&... args);
};

WRITE_CLASS_ENCODER(MClientRequest::Release)

#endif
Commit	Line	Data
7c673cae FG	1	// -- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t --
	2	// vim: ts=8 sw=2 smarttab
	3	/*
	4	* Ceph - scalable distributed file system
	5	*
	6	* Copyright (C) 2004-2006 Sage Weil <sage@newdream.net>
	7	*
	8	* This is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU Lesser General Public
	10	* License version 2.1, as published by the Free Software
	11	* Foundation. See file COPYING.
	12	*
	13	*/
	14
	15
	16	#ifndef CEPH_MCLIENTREQUEST_H
	17	#define CEPH_MCLIENTREQUEST_H
	18
	19	/**
	20	*
	21	* MClientRequest - container for a client METADATA request. created/sent by clients.
	22	* can be forwarded around between MDS's.
	23	*
	24	* int client - the originating client
	25	* long tid - transaction id, unique among requests for that client. probably just a counter!
	26	* -> the MDS passes the Request to the Reply constructor, so this always matches.
	27	*
	28	* int op - the metadata op code. MDS_OP_RENAME, etc.
	29	* int caller_uid, _gid - guess
	30	*
	31	* fixed size arguments are in a union.
	32	* there's also a string argument, for e.g. symlink().
	33	*
	34	*/
	35
11fdf7f2	36	#include <string_view>
94b18763	37
7c673cae FG	38	#include "msg/Message.h"
	39	#include "include/filepath.h"
	40	#include "mds/mdstypes.h"
	41	#include "include/ceph_features.h"
	42
	43	#include <sys/types.h>
	44	#include <utime.h>
	45	#include <sys/stat.h>
	46	#include <fcntl.h>
	47
	48
	49	// metadata ops.
	50
9f95a23c	51	class MClientRequest : public SafeMessage {
11fdf7f2 TL	52	private:
	53	static constexpr int HEAD_VERSION = 4;
	54	static constexpr int COMPAT_VERSION = 1;
7c673cae FG	55
7c673cae FG	56	public:
11fdf7f2	57	mutable struct ceph_mds_request_head head; /* XXX HACK! */
7c673cae FG	58	utime_t stamp;
	59
	60	struct Release {
	61	mutable ceph_mds_request_release item;
	62	string dname;
	63
	64	Release() : item(), dname() {}
	65	Release(const ceph_mds_request_release& rel, string name) :
	66	item(rel), dname(name) {}
	67
	68	void encode(bufferlist& bl) const {
11fdf7f2	69	using ceph::encode;
7c673cae	70	item.dname_len = dname.length();
11fdf7f2 TL	71	encode(item, bl);
11fdf7f2 TL	72	encode_nohead(dname, bl);
7c673cae	73	}
11fdf7f2 TL	74	void decode(bufferlist::const_iterator& bl) {
	75	using ceph::decode;
	76	decode(item, bl);
	77	decode_nohead(item.dname_len, dname, bl);
7c673cae FG	78	}
7c673cae FG	79	};
11fdf7f2	80	mutable vector<Release> releases; /* XXX HACK! */
7c673cae FG	81
	82	// path arguments
	83	filepath path, path2;
	84	vector<uint64_t> gid_list;
	85
11fdf7f2 TL	86	/* XXX HACK */
11fdf7f2 TL	87	mutable bool queued_for_replay = false;
7c673cae	88
11fdf7f2	89	protected:
7c673cae FG	90	// cons
7c673cae FG	91	MClientRequest()
9f95a23c	92	: SafeMessage(CEPH_MSG_CLIENT_REQUEST, HEAD_VERSION, COMPAT_VERSION) {}
7c673cae	93	MClientRequest(int op)
9f95a23c	94	: SafeMessage(CEPH_MSG_CLIENT_REQUEST, HEAD_VERSION, COMPAT_VERSION) {
7c673cae FG	95	memset(&head, 0, sizeof(head));
	96	head.op = op;
	97	}
7c673cae FG	98	~MClientRequest() override {}
	99
	100	public:
	101	void set_mdsmap_epoch(epoch_t e) { head.mdsmap_epoch = e; }
11fdf7f2	102	epoch_t get_mdsmap_epoch() const { return head.mdsmap_epoch; }
7c673cae	103	epoch_t get_osdmap_epoch() const {
11fdf7f2	104	ceph_assert(head.op == CEPH_MDS_OP_SETXATTR);
7c673cae FG	105	if (header.version >= 3)
	106	return head.args.setxattr.osdmap_epoch;
	107	else
	108	return 0;
	109	}
	110	void set_osdmap_epoch(epoch_t e) {
11fdf7f2	111	ceph_assert(head.op == CEPH_MDS_OP_SETXATTR);
7c673cae FG	112	head.args.setxattr.osdmap_epoch = e;
	113	}
	114
11fdf7f2	115	metareqid_t get_reqid() const {
7c673cae FG	116	// FIXME: for now, assume clients always have 1 incarnation
	117	return metareqid_t(get_orig_source(), header.tid);
	118	}
	119
	120	/*bool open_file_mode_is_readonly() {
	121	return file_mode_is_readonly(ceph_flags_to_mode(head.args.open.flags));
	122	}*/
11fdf7f2	123	bool may_write() const {
7c673cae FG	124	return
	125	(head.op & CEPH_MDS_OP_WRITE) \|\|
	126	(head.op == CEPH_MDS_OP_OPEN && (head.args.open.flags & (O_CREAT\|O_TRUNC)));
	127	}
	128
	129	int get_flags() const {
	130	return head.flags;
	131	}
11fdf7f2	132	bool is_replay() const {
7c673cae FG	133	return get_flags() & CEPH_MDS_FLAG_REPLAY;
7c673cae FG	134	}
9f95a23c TL	135	bool is_async() const {
	136	return get_flags() & CEPH_MDS_FLAG_ASYNC;
	137	}
7c673cae FG	138
	139	// normal fields
	140	void set_stamp(utime_t t) { stamp = t; }
	141	void set_oldest_client_tid(ceph_tid_t t) { head.oldest_client_tid = t; }
	142	void inc_num_fwd() { head.num_fwd = head.num_fwd + 1; }
	143	void set_retry_attempt(int a) { head.num_retry = a; }
	144	void set_filepath(const filepath& fp) { path = fp; }
	145	void set_filepath2(const filepath& fp) { path2 = fp; }
11fdf7f2	146	void set_string2(const char *s) { path2.set_path(std::string_view(s), 0); }
7c673cae FG	147	void set_caller_uid(unsigned u) { head.caller_uid = u; }
	148	void set_caller_gid(unsigned g) { head.caller_gid = g; }
	149	void set_gid_list(int count, const gid_t *gids) {
	150	gid_list.reserve(count);
	151	for (int i = 0; i < count; ++i) {
	152	gid_list.push_back(gids[i]);
	153	}
	154	}
	155	void set_dentry_wanted() {
	156	head.flags = head.flags \| CEPH_MDS_FLAG_WANT_DENTRY;
	157	}
	158	void set_replayed_op() {
	159	head.flags = head.flags \| CEPH_MDS_FLAG_REPLAY;
	160	}
9f95a23c TL	161	void set_async_op() {
	162	head.flags = head.flags \| CEPH_MDS_FLAG_ASYNC;
	163	}
7c673cae FG	164
	165	utime_t get_stamp() const { return stamp; }
	166	ceph_tid_t get_oldest_client_tid() const { return head.oldest_client_tid; }
	167	int get_num_fwd() const { return head.num_fwd; }
	168	int get_retry_attempt() const { return head.num_retry; }
	169	int get_op() const { return head.op; }
	170	unsigned get_caller_uid() const { return head.caller_uid; }
	171	unsigned get_caller_gid() const { return head.caller_gid; }
	172	const vector<uint64_t>& get_caller_gid_list() const { return gid_list; }
	173
	174	const string& get_path() const { return path.get_path(); }
	175	const filepath& get_filepath() const { return path; }
	176	const string& get_path2() const { return path2.get_path(); }
	177	const filepath& get_filepath2() const { return path2; }
	178
11fdf7f2	179	int get_dentry_wanted() const { return get_flags() & CEPH_MDS_FLAG_WANT_DENTRY; }
7c673cae	180
11fdf7f2 TL	181	void mark_queued_for_replay() const { queued_for_replay = true; }
11fdf7f2 TL	182	bool is_queued_for_replay() const { return queued_for_replay; }
7c673cae FG	183
7c673cae FG	184	void decode_payload() override {
11fdf7f2	185	auto p = payload.cbegin();
7c673cae FG	186
7c673cae FG	187	if (header.version >= 4) {
11fdf7f2	188	decode(head, p);
7c673cae FG	189	} else {
	190	struct ceph_mds_request_head_legacy old_mds_head;
	191
11fdf7f2	192	decode(old_mds_head, p);
7c673cae FG	193	copy_from_legacy_head(&head, &old_mds_head);
	194	head.version = 0;
	195
	196	/* Can't set the btime from legacy struct */
	197	if (head.op == CEPH_MDS_OP_SETATTR) {
	198	int localmask = head.args.setattr.mask;
	199
	200	localmask &= ~CEPH_SETATTR_BTIME;
	201
9f95a23c	202	head.args.setattr.btime = { init_le32(0), init_le32(0) };
7c673cae FG	203	head.args.setattr.mask = localmask;
	204	}
	205	}
	206
11fdf7f2 TL	207	decode(path, p);
	208	decode(path2, p);
	209	decode_nohead(head.num_releases, releases, p);
7c673cae	210	if (header.version >= 2)
11fdf7f2	211	decode(stamp, p);
7c673cae	212	if (header.version >= 4) // epoch 3 was for a ceph_mds_request_args change
11fdf7f2	213	decode(gid_list, p);
7c673cae FG	214	}
	215
	216	void encode_payload(uint64_t features) override {
11fdf7f2	217	using ceph::encode;
7c673cae FG	218	head.num_releases = releases.size();
	219	head.version = CEPH_MDS_REQUEST_HEAD_VERSION;
	220
	221	if (features & CEPH_FEATURE_FS_BTIME) {
11fdf7f2	222	encode(head, payload);
7c673cae FG	223	} else {
	224	struct ceph_mds_request_head_legacy old_mds_head;
	225
	226	copy_to_legacy_head(&old_mds_head, &head);
11fdf7f2	227	encode(old_mds_head, payload);
7c673cae FG	228	}
7c673cae FG	229
11fdf7f2 TL	230	encode(path, payload);
	231	encode(path2, payload);
	232	encode_nohead(releases, payload);
	233	encode(stamp, payload);
	234	encode(gid_list, payload);
7c673cae FG	235	}
7c673cae FG	236
11fdf7f2	237	std::string_view get_type_name() const override { return "creq"; }
7c673cae FG	238	void print(ostream& out) const override {
	239	out << "client_request(" << get_orig_source()
	240	<< ":" << get_tid()
	241	<< " " << ceph_mds_op_name(get_op());
	242	if (head.op == CEPH_MDS_OP_GETATTR)
	243	out << " " << ccap_string(head.args.getattr.mask);
	244	if (head.op == CEPH_MDS_OP_SETATTR) {
	245	if (head.args.setattr.mask & CEPH_SETATTR_MODE)
	246	out << " mode=0" << std::oct << head.args.setattr.mode << std::dec;
	247	if (head.args.setattr.mask & CEPH_SETATTR_UID)
	248	out << " uid=" << head.args.setattr.uid;
	249	if (head.args.setattr.mask & CEPH_SETATTR_GID)
	250	out << " gid=" << head.args.setattr.gid;
	251	if (head.args.setattr.mask & CEPH_SETATTR_SIZE)
	252	out << " size=" << head.args.setattr.size;
	253	if (head.args.setattr.mask & CEPH_SETATTR_MTIME)
	254	out << " mtime=" << utime_t(head.args.setattr.mtime);
	255	if (head.args.setattr.mask & CEPH_SETATTR_ATIME)
	256	out << " atime=" << utime_t(head.args.setattr.atime);
	257	}
	258	if (head.op == CEPH_MDS_OP_SETFILELOCK \|\|
	259	head.op == CEPH_MDS_OP_GETFILELOCK) {
11fdf7f2	260	out << " rule " << (int)head.args.filelock_change.rule
7c673cae FG	261	<< ", type " << (int)head.args.filelock_change.type
	262	<< ", owner " << head.args.filelock_change.owner
	263	<< ", pid " << head.args.filelock_change.pid
	264	<< ", start " << head.args.filelock_change.start
	265	<< ", length " << head.args.filelock_change.length
	266	<< ", wait " << (int)head.args.filelock_change.wait;
	267	}
	268	//if (!get_filepath().empty())
	269	out << " " << get_filepath();
	270	if (!get_filepath2().empty())
	271	out << " " << get_filepath2();
	272	if (stamp != utime_t())
	273	out << " " << stamp;
	274	if (head.num_retry)
	275	out << " RETRY=" << (int)head.num_retry;
9f95a23c TL	276	if (is_async())
	277	out << " ASYNC";
	278	if (is_replay())
7c673cae FG	279	out << " REPLAY";
	280	if (queued_for_replay)
	281	out << " QUEUED_FOR_REPLAY";
	282	out << " caller_uid=" << head.caller_uid
	283	<< ", caller_gid=" << head.caller_gid
	284	<< '{';
	285	for (auto i = gid_list.begin(); i != gid_list.end(); ++i)
	286	out << *i << ',';
	287	out << '}'
	288	<< ")";
	289	}
9f95a23c TL	290	private:
	291	template<class T, typename... Args>
	292	friend boost::intrusive_ptr<T> ceph::make_message(Args&&... args);
7c673cae FG	293	};
	294
	295	WRITE_CLASS_ENCODER(MClientRequest::Release)
	296
	297	#endif