[ceph.git] / ceph / src / include / types.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_TYPES_H
#define CEPH_TYPES_H

// this is needed for ceph_fs to compile in userland
#include "int_types.h"
#include "byteorder.h"

#include "uuid.h"

#include <netinet/in.h>
#include <fcntl.h>
#include <string.h>

// <macro hackery>
// temporarily remap __le* to ceph_le* for benefit of shared kernel/userland headers
#define __le16 ceph_le16
#define __le32 ceph_le32
#define __le64 ceph_le64
#include "ceph_fs.h"
#include "ceph_frag.h"
#include "rbd_types.h"
#undef __le16
#undef __le32
#undef __le64
// </macro hackery>


#ifdef __cplusplus
#ifndef _BACKWARD_BACKWARD_WARNING_H
#define _BACKWARD_BACKWARD_WARNING_H   // make gcc 4.3 shut up about hash_*
#endif
#endif

extern "C" {
#include <stdint.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "statlite.h"
}

#include <string>
#include <list>
#include <set>
#include <map>
#include <vector>
#include <iostream>
#include <iomanip>

using namespace std;

#include "include/unordered_map.h"

#include "object.h"
#include "intarith.h"

#include "acconfig.h"

#include "assert.h"

// DARWIN compatibility
#ifdef DARWIN
typedef long long loff_t;
typedef long long off64_t;
#define O_DIRECT 00040000
#endif

// FreeBSD compatibility
#ifdef __FreeBSD__
typedef off_t loff_t;
typedef off_t off64_t;
#endif

#if defined(__sun) || defined(_AIX)
typedef off_t loff_t;
#endif


// -- io helpers --

// Forward declare all the I/O helpers so strict ADL can find them in
// the case of containers of containers. I'm tempted to abstract this
// stuff using template templates like I did for denc.

template<class A, class B>
inline ostream& operator<<(ostream&out, const pair<A,B>& v);
template<class A, class Alloc>
inline ostream& operator<<(ostream& out, const vector<A,Alloc>& v);
template<class A, class Comp, class Alloc>
inline ostream& operator<<(ostream& out, const deque<A,Alloc>& v);
template<class A, class B, class C>
inline ostream& operator<<(ostream&out, const boost::tuple<A, B, C> &t);
template<class A, class Alloc>
inline ostream& operator<<(ostream& out, const list<A,Alloc>& ilist);
template<class A, class Comp, class Alloc>
inline ostream& operator<<(ostream& out, const set<A, Comp, Alloc>& iset);
template<class A, class Comp, class Alloc>
inline ostream& operator<<(ostream& out, const multiset<A,Comp,Alloc>& iset);
template<class A, class B, class Comp, class Alloc>
inline ostream& operator<<(ostream& out, const map<A,B,Comp,Alloc>& m);
template<class A, class B, class Comp, class Alloc>
inline ostream& operator<<(ostream& out, const multimap<A,B,Comp,Alloc>& m);

template<class A, class B>
inline ostream& operator<<(ostream& out, const pair<A,B>& v) {
  return out << v.first << "," << v.second;
}

template<class A, class Alloc>
inline ostream& operator<<(ostream& out, const vector<A,Alloc>& v) {
  out << "[";
  for (auto p = v.begin(); p != v.end(); ++p) {
    if (p != v.begin()) out << ",";
    out << *p;
  }
  out << "]";
  return out;
}
template<class A, class Alloc>
inline ostream& operator<<(ostream& out, const deque<A,Alloc>& v) {
  out << "<";
  for (auto p = v.begin(); p != v.end(); ++p) {
    if (p != v.begin()) out << ",";
    out << *p;
  }
  out << ">";
  return out;
}

template<class A, class B, class C>
inline ostream& operator<<(ostream&out, const boost::tuple<A, B, C> &t) {
  out << boost::get<0>(t) <<"," << boost::get<1>(t) << "," << boost::get<2>(t);
  return out;
}

template<class A, class Alloc>
inline ostream& operator<<(ostream& out, const list<A,Alloc>& ilist) {
  for (auto it = ilist.begin();
       it != ilist.end();
       ++it) {
    if (it != ilist.begin()) out << ",";
    out << *it;
  }
  return out;
}

template<class A, class Comp, class Alloc>
inline ostream& operator<<(ostream& out, const set<A, Comp, Alloc>& iset) {
  for (auto it = iset.begin();
       it != iset.end();
       ++it) {
    if (it != iset.begin()) out << ",";
    out << *it;
  }
  return out;
}

template<class A, class Comp, class Alloc>
inline ostream& operator<<(ostream& out, const multiset<A,Comp,Alloc>& iset) {
  for (auto it = iset.begin();
       it != iset.end();
       ++it) {
    if (it != iset.begin()) out << ",";
    out << *it;
  }
  return out;
}

template<class A, class B, class Comp, class Alloc>
inline ostream& operator<<(ostream& out, const map<A,B,Comp,Alloc>& m)
{
  out << "{";
  for (auto it = m.begin();
       it != m.end();
       ++it) {
    if (it != m.begin()) out << ",";
    out << it->first << "=" << it->second;
  }
  out << "}";
  return out;
}

template<class A, class B, class Comp, class Alloc>
inline ostream& operator<<(ostream& out, const multimap<A,B,Comp,Alloc>& m)
{
  out << "{{";
  for (auto it = m.begin();
       it != m.end();
       ++it) {
    if (it != m.begin()) out << ",";
    out << it->first << "=" << it->second;
  }
  out << "}}";
  return out;
}


/*
 * comparators for stl containers
 */
// for ceph::unordered_map:
//   ceph::unordered_map<const char*, long, hash<const char*>, eqstr> vals;
struct eqstr
{
  bool operator()(const char* s1, const char* s2) const
  {
    return strcmp(s1, s2) == 0;
  }
};

// for set, map
struct ltstr
{
  bool operator()(const char* s1, const char* s2) const
  {
    return strcmp(s1, s2) < 0;
  }
};


namespace ceph {
  class Formatter;
}

#include "encoding.h"

WRITE_RAW_ENCODER(ceph_fsid)
WRITE_RAW_ENCODER(ceph_file_layout)
WRITE_RAW_ENCODER(ceph_dir_layout)
WRITE_RAW_ENCODER(ceph_mds_session_head)
WRITE_RAW_ENCODER(ceph_mds_request_head_legacy)
WRITE_RAW_ENCODER(ceph_mds_request_head)
WRITE_RAW_ENCODER(ceph_mds_request_release)
WRITE_RAW_ENCODER(ceph_filelock)
WRITE_RAW_ENCODER(ceph_mds_caps_head)
WRITE_RAW_ENCODER(ceph_mds_caps_body_legacy)
WRITE_RAW_ENCODER(ceph_mds_cap_peer)
WRITE_RAW_ENCODER(ceph_mds_cap_release)
WRITE_RAW_ENCODER(ceph_mds_cap_item)
WRITE_RAW_ENCODER(ceph_mds_lease)
WRITE_RAW_ENCODER(ceph_mds_snap_head)
WRITE_RAW_ENCODER(ceph_mds_snap_realm)
WRITE_RAW_ENCODER(ceph_mds_reply_head)
WRITE_RAW_ENCODER(ceph_mds_reply_cap)
WRITE_RAW_ENCODER(ceph_mds_cap_reconnect)
WRITE_RAW_ENCODER(ceph_mds_snaprealm_reconnect)
WRITE_RAW_ENCODER(ceph_frag_tree_split)
WRITE_RAW_ENCODER(ceph_osd_reply_head)
WRITE_RAW_ENCODER(ceph_osd_op)
WRITE_RAW_ENCODER(ceph_msg_header)
WRITE_RAW_ENCODER(ceph_msg_footer)
WRITE_RAW_ENCODER(ceph_msg_footer_old)
WRITE_RAW_ENCODER(ceph_mon_subscribe_item)

WRITE_RAW_ENCODER(ceph_mon_statfs)
WRITE_RAW_ENCODER(ceph_mon_statfs_reply)

// ----------------------
// some basic types

// NOTE: these must match ceph_fs.h typedefs
typedef uint64_t ceph_tid_t; // transaction id
typedef uint64_t version_t;
typedef __u32 epoch_t;       // map epoch  (32bits -> 13 epochs/second for 10 years)

// --------------------------------------
// identify individual mount clients by 64bit value

struct client_t {
  int64_t v;

  // cppcheck-suppress noExplicitConstructor
  client_t(int64_t _v = -2) : v(_v) {}
  
  void encode(bufferlist& bl) const {
    ::encode(v, bl);
  }
  void decode(bufferlist::iterator& bl) {
    ::decode(v, bl);
  }
};
WRITE_CLASS_ENCODER(client_t)

static inline bool operator==(const client_t& l, const client_t& r) { return l.v == r.v; }
static inline bool operator!=(const client_t& l, const client_t& r) { return l.v != r.v; }
static inline bool operator<(const client_t& l, const client_t& r) { return l.v < r.v; }
static inline bool operator<=(const client_t& l, const client_t& r) { return l.v <= r.v; }
static inline bool operator>(const client_t& l, const client_t& r) { return l.v > r.v; }
static inline bool operator>=(const client_t& l, const client_t& r) { return l.v >= r.v; }

static inline bool operator>=(const client_t& l, int64_t o) { return l.v >= o; }
static inline bool operator<(const client_t& l, int64_t o) { return l.v < o; }

inline ostream& operator<<(ostream& out, const client_t& c) {
  return out << c.v;
}


// --

struct prettybyte_t {
  uint64_t v;
  // cppcheck-suppress noExplicitConstructor
  prettybyte_t(uint64_t _v) : v(_v) {}
};

inline ostream& operator<<(ostream& out, const prettybyte_t& b)
{
  uint64_t bump_after = 100;
  if (b.v > bump_after << 60)
    return out << (b.v >> 60) << " EB";    
  if (b.v > bump_after << 50)
    return out << (b.v >> 50) << " PB";    
  if (b.v > bump_after << 40)
    return out << (b.v >> 40) << " TB";    
  if (b.v > bump_after << 30)
    return out << (b.v >> 30) << " GB";    
  if (b.v > bump_after << 20)
    return out << (b.v >> 20) << " MB";    
  if (b.v > bump_after << 10)
    return out << (b.v >> 10) << " kB";
  return out << b.v << " bytes";
}

struct si_t {
  uint64_t v;
  // cppcheck-suppress noExplicitConstructor
  si_t(uint64_t _v) : v(_v) {}
};

inline ostream& operator<<(ostream& out, const si_t& b)
{
  uint64_t bump_after = 100;
  if (b.v > bump_after << 60)
    return out << (b.v >> 60) << "E";
  if (b.v > bump_after << 50)
    return out << (b.v >> 50) << "P";
  if (b.v > bump_after << 40)
    return out << (b.v >> 40) << "T";
  if (b.v > bump_after << 30)
    return out << (b.v >> 30) << "G";
  if (b.v > bump_after << 20)
    return out << (b.v >> 20) << "M";
  if (b.v > bump_after << 10)
    return out << (b.v >> 10) << "k";
  return out << b.v;
}

struct pretty_si_t {
  uint64_t v;
  // cppcheck-suppress noExplicitConstructor
  pretty_si_t(uint64_t _v) : v(_v) {}
};

inline ostream& operator<<(ostream& out, const pretty_si_t& b)
{
  uint64_t bump_after = 100;
  if (b.v > bump_after << 60)
    return out << (b.v >> 60) << " E";
  if (b.v > bump_after << 50)
    return out << (b.v >> 50) << " P";
  if (b.v > bump_after << 40)
    return out << (b.v >> 40) << " T";
  if (b.v > bump_after << 30)
    return out << (b.v >> 30) << " G";
  if (b.v > bump_after << 20)
    return out << (b.v >> 20) << " M";
  if (b.v > bump_after << 10)
    return out << (b.v >> 10) << " k";
  return out << b.v << " ";
}

struct kb_t {
  uint64_t v;
  // cppcheck-suppress noExplicitConstructor
  kb_t(uint64_t _v) : v(_v) {}
};

inline ostream& operator<<(ostream& out, const kb_t& kb)
{
  uint64_t bump_after = 100;
  if (kb.v > bump_after << 40)
    return out << (kb.v >> 40) << " PB";    
  if (kb.v > bump_after << 30)
    return out << (kb.v >> 30) << " TB";    
  if (kb.v > bump_after << 20)
    return out << (kb.v >> 20) << " GB";    
  if (kb.v > bump_after << 10)
    return out << (kb.v >> 10) << " MB";
  return out << kb.v << " kB";
}

inline ostream& operator<<(ostream& out, const ceph_mon_subscribe_item& i)
{
  return out << i.start
	     << ((i.flags & CEPH_SUBSCRIBE_ONETIME) ? "" : "+");
}

struct weightf_t {
  float v;
  // cppcheck-suppress noExplicitConstructor
  weightf_t(float _v) : v(_v) {}
};

inline ostream& operator<<(ostream& out, const weightf_t& w)
{
  if (w.v < -0.01) {
    return out << "-";
  } else if (w.v < 0.000001) {
    return out << "0";
  } else {
    std::streamsize p = out.precision();
    return out << std::fixed << std::setprecision(5) << w.v << std::setprecision(p);
  }
}

struct shard_id_t {
  int8_t id;

  shard_id_t() : id(0) {}
  explicit shard_id_t(int8_t _id) : id(_id) {}

  operator int8_t() const { return id; }

  const static shard_id_t NO_SHARD;

  void encode(bufferlist &bl) const {
    ::encode(id, bl);
  }
  void decode(bufferlist::iterator &bl) {
    ::decode(id, bl);
  }
};
WRITE_CLASS_ENCODER(shard_id_t)
WRITE_EQ_OPERATORS_1(shard_id_t, id)
WRITE_CMP_OPERATORS_1(shard_id_t, id)
ostream &operator<<(ostream &lhs, const shard_id_t &rhs);

#if defined(__sun) || defined(_AIX) || defined(DARWIN) || defined(__FreeBSD__)
__s32  ceph_to_hostos_errno(__s32 e);
__s32  hostos_to_ceph_errno(__s32 e);
#else
#define  ceph_to_hostos_errno(e) (e)
#define  hostos_to_ceph_errno(e) (e)
#endif

struct errorcode32_t {
  int32_t code;

  errorcode32_t() : code(0) {}
  // cppcheck-suppress noExplicitConstructor
  errorcode32_t(int32_t i) : code(i) {}

  operator int() const  { return code; }
  int* operator&()      { return &code; }
  int operator==(int i) { return code == i; }
  int operator>(int i)  { return code > i; }
  int operator>=(int i) { return code >= i; }
  int operator<(int i)  { return code < i; }
  int operator<=(int i) { return code <= i; }

  void encode(bufferlist &bl) const {
    __s32 newcode = hostos_to_ceph_errno(code);
    ::encode(newcode, bl);
  }
  void decode(bufferlist::iterator &bl) {
    ::decode(code, bl);
    code = ceph_to_hostos_errno(code);
  }
};
WRITE_CLASS_ENCODER(errorcode32_t)
WRITE_EQ_OPERATORS_1(errorcode32_t, code)
WRITE_CMP_OPERATORS_1(errorcode32_t, code)


#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	#ifndef CEPH_TYPES_H
	15	#define CEPH_TYPES_H
	16
	17	// this is needed for ceph_fs to compile in userland
	18	#include "int_types.h"
	19	#include "byteorder.h"
	20
	21	#include "uuid.h"
	22
	23	#include <netinet/in.h>
	24	#include <fcntl.h>
	25	#include <string.h>
	26
	27	// <macro hackery>
	28	// temporarily remap __le* to ceph_le* for benefit of shared kernel/userland headers
	29	#define __le16 ceph_le16
	30	#define __le32 ceph_le32
	31	#define __le64 ceph_le64
	32	#include "ceph_fs.h"
	33	#include "ceph_frag.h"
	34	#include "rbd_types.h"
	35	#undef __le16
	36	#undef __le32
	37	#undef __le64
	38	// </macro hackery>
	39
	40
	41	#ifdef __cplusplus
	42	#ifndef _BACKWARD_BACKWARD_WARNING_H
	43	#define _BACKWARD_BACKWARD_WARNING_H // make gcc 4.3 shut up about hash_*
	44	#endif
	45	#endif
	46
	47	extern "C" {
	48	#include <stdint.h>
	49	#include <sys/types.h>
	50	#include <sys/stat.h>
	51	#include "statlite.h"
	52	}
	53
	54	#include <string>
	55	#include <list>
	56	#include <set>
	57	#include <map>
	58	#include <vector>
	59	#include <iostream>
	60	#include <iomanip>
	61
	62	using namespace std;
	63
	64	#include "include/unordered_map.h"
65
66	#include "object.h"
67	#include "intarith.h"
68
69	#include "acconfig.h"
70
71	#include "assert.h"
72
73	// DARWIN compatibility
74	#ifdef DARWIN
75	typedef long long loff_t;
76	typedef long long off64_t;
77	#define O_DIRECT 00040000
78	#endif
79
80	// FreeBSD compatibility
81	#ifdef __FreeBSD__
82	typedef off_t loff_t;
83	typedef off_t off64_t;
84	#endif
85
86	#if defined(__sun) \|\| defined(_AIX)
87	typedef off_t loff_t;
88	#endif
89
90
91	// -- io helpers --
92
31f18b77 FG	93	// Forward declare all the I/O helpers so strict ADL can find them in
	94	// the case of containers of containers. I'm tempted to abstract this
	95	// stuff using template templates like I did for denc.
	96
	97	template<class A, class B>
	98	inline ostream& operator<<(ostream&out, const pair<A,B>& v);
	99	template<class A, class Alloc>
	100	inline ostream& operator<<(ostream& out, const vector<A,Alloc>& v);
	101	template<class A, class Comp, class Alloc>
	102	inline ostream& operator<<(ostream& out, const deque<A,Alloc>& v);
	103	template<class A, class B, class C>
	104	inline ostream& operator<<(ostream&out, const boost::tuple<A, B, C> &t);
	105	template<class A, class Alloc>
	106	inline ostream& operator<<(ostream& out, const list<A,Alloc>& ilist);
	107	template<class A, class Comp, class Alloc>
	108	inline ostream& operator<<(ostream& out, const set<A, Comp, Alloc>& iset);
	109	template<class A, class Comp, class Alloc>
	110	inline ostream& operator<<(ostream& out, const multiset<A,Comp,Alloc>& iset);
	111	template<class A, class B, class Comp, class Alloc>
	112	inline ostream& operator<<(ostream& out, const map<A,B,Comp,Alloc>& m);
	113	template<class A, class B, class Comp, class Alloc>
	114	inline ostream& operator<<(ostream& out, const multimap<A,B,Comp,Alloc>& m);
	115
7c673cae FG	116	template<class A, class B>
	117	inline ostream& operator<<(ostream& out, const pair<A,B>& v) {
	118	return out << v.first << "," << v.second;
	119	}
	120
	121	template<class A, class Alloc>
	122	inline ostream& operator<<(ostream& out, const vector<A,Alloc>& v) {
	123	out << "[";
	124	for (auto p = v.begin(); p != v.end(); ++p) {
	125	if (p != v.begin()) out << ",";
	126	out << *p;
	127	}
	128	out << "]";
	129	return out;
	130	}
	131	template<class A, class Alloc>
	132	inline ostream& operator<<(ostream& out, const deque<A,Alloc>& v) {
	133	out << "<";
	134	for (auto p = v.begin(); p != v.end(); ++p) {
	135	if (p != v.begin()) out << ",";
	136	out << *p;
	137	}
	138	out << ">";
	139	return out;
	140	}
	141
	142	template<class A, class B, class C>
	143	inline ostream& operator<<(ostream&out, const boost::tuple<A, B, C> &t) {
	144	out << boost::get<0>(t) <<"," << boost::get<1>(t) << "," << boost::get<2>(t);
	145	return out;
	146	}
	147
	148	template<class A, class Alloc>
	149	inline ostream& operator<<(ostream& out, const list<A,Alloc>& ilist) {
	150	for (auto it = ilist.begin();
	151	it != ilist.end();
	152	++it) {
	153	if (it != ilist.begin()) out << ",";
	154	out << *it;
	155	}
	156	return out;
	157	}
	158
	159	template<class A, class Comp, class Alloc>
	160	inline ostream& operator<<(ostream& out, const set<A, Comp, Alloc>& iset) {
	161	for (auto it = iset.begin();
	162	it != iset.end();
	163	++it) {
	164	if (it != iset.begin()) out << ",";
	165	out << *it;
	166	}
	167	return out;
	168	}
	169
	170	template<class A, class Comp, class Alloc>
	171	inline ostream& operator<<(ostream& out, const multiset<A,Comp,Alloc>& iset) {
	172	for (auto it = iset.begin();
	173	it != iset.end();
	174	++it) {
	175	if (it != iset.begin()) out << ",";
	176	out << *it;
	177	}
	178	return out;
	179	}
180
181	template<class A, class B, class Comp, class Alloc>
182	inline ostream& operator<<(ostream& out, const map<A,B,Comp,Alloc>& m)
183	{
184	out << "{";
185	for (auto it = m.begin();
186	it != m.end();
187	++it) {
188	if (it != m.begin()) out << ",";
189	out << it->first << "=" << it->second;
190	}
191	out << "}";
192	return out;
193	}
194
195	template<class A, class B, class Comp, class Alloc>
196	inline ostream& operator<<(ostream& out, const multimap<A,B,Comp,Alloc>& m)
197	{
198	out << "{{";
199	for (auto it = m.begin();
200	it != m.end();
201	++it) {
202	if (it != m.begin()) out << ",";
203	out << it->first << "=" << it->second;
204	}
205	out << "}}";
206	return out;
207	}
208
209
210
211
212	/*
213	* comparators for stl containers
214	*/
215	// for ceph::unordered_map:
216	// ceph::unordered_map<const char, long, hash<const char>, eqstr> vals;
217	struct eqstr
218	{
219	bool operator()(const char* s1, const char* s2) const
220	{
221	return strcmp(s1, s2) == 0;
222	}
223	};
224
225	// for set, map
226	struct ltstr
227	{
228	bool operator()(const char* s1, const char* s2) const
229	{
230	return strcmp(s1, s2) < 0;
231	}
232	};
233
234
235	namespace ceph {
236	class Formatter;
237	}
238
239	#include "encoding.h"
240
241	WRITE_RAW_ENCODER(ceph_fsid)
242	WRITE_RAW_ENCODER(ceph_file_layout)
243	WRITE_RAW_ENCODER(ceph_dir_layout)
244	WRITE_RAW_ENCODER(ceph_mds_session_head)
245	WRITE_RAW_ENCODER(ceph_mds_request_head_legacy)
246	WRITE_RAW_ENCODER(ceph_mds_request_head)
247	WRITE_RAW_ENCODER(ceph_mds_request_release)
248	WRITE_RAW_ENCODER(ceph_filelock)
249	WRITE_RAW_ENCODER(ceph_mds_caps_head)
250	WRITE_RAW_ENCODER(ceph_mds_caps_body_legacy)
251	WRITE_RAW_ENCODER(ceph_mds_cap_peer)
252	WRITE_RAW_ENCODER(ceph_mds_cap_release)
253	WRITE_RAW_ENCODER(ceph_mds_cap_item)
254	WRITE_RAW_ENCODER(ceph_mds_lease)
255	WRITE_RAW_ENCODER(ceph_mds_snap_head)
256	WRITE_RAW_ENCODER(ceph_mds_snap_realm)
257	WRITE_RAW_ENCODER(ceph_mds_reply_head)
258	WRITE_RAW_ENCODER(ceph_mds_reply_cap)
259	WRITE_RAW_ENCODER(ceph_mds_cap_reconnect)
260	WRITE_RAW_ENCODER(ceph_mds_snaprealm_reconnect)
261	WRITE_RAW_ENCODER(ceph_frag_tree_split)
262	WRITE_RAW_ENCODER(ceph_osd_reply_head)
263	WRITE_RAW_ENCODER(ceph_osd_op)
264	WRITE_RAW_ENCODER(ceph_msg_header)
265	WRITE_RAW_ENCODER(ceph_msg_footer)
266	WRITE_RAW_ENCODER(ceph_msg_footer_old)
267	WRITE_RAW_ENCODER(ceph_mon_subscribe_item)
268
269	WRITE_RAW_ENCODER(ceph_mon_statfs)
270	WRITE_RAW_ENCODER(ceph_mon_statfs_reply)
271
272	// ----------------------
273	// some basic types
274
275	// NOTE: these must match ceph_fs.h typedefs
276	typedef uint64_t ceph_tid_t; // transaction id
277	typedef uint64_t version_t;
278	typedef __u32 epoch_t; // map epoch (32bits -> 13 epochs/second for 10 years)
279
280	// --------------------------------------
281	// identify individual mount clients by 64bit value
282
283	struct client_t {
284	int64_t v;
285
286	// cppcheck-suppress noExplicitConstructor
287	client_t(int64_t _v = -2) : v(_v) {}
288
289	void encode(bufferlist& bl) const {
290	::encode(v, bl);
291	}
292	void decode(bufferlist::iterator& bl) {
293	::decode(v, bl);
294	}
295	};
296	WRITE_CLASS_ENCODER(client_t)
297
298	static inline bool operator==(const client_t& l, const client_t& r) { return l.v == r.v; }
299	static inline bool operator!=(const client_t& l, const client_t& r) { return l.v != r.v; }
300	static inline bool operator<(const client_t& l, const client_t& r) { return l.v < r.v; }
301	static inline bool operator<=(const client_t& l, const client_t& r) { return l.v <= r.v; }
302	static inline bool operator>(const client_t& l, const client_t& r) { return l.v > r.v; }
303	static inline bool operator>=(const client_t& l, const client_t& r) { return l.v >= r.v; }
304
305	static inline bool operator>=(const client_t& l, int64_t o) { return l.v >= o; }
306	static inline bool operator<(const client_t& l, int64_t o) { return l.v < o; }
307
308	inline ostream& operator<<(ostream& out, const client_t& c) {
309	return out << c.v;
310	}
311
312
313
314	// --
315
316	struct prettybyte_t {
317	uint64_t v;
318	// cppcheck-suppress noExplicitConstructor
319	prettybyte_t(uint64_t _v) : v(_v) {}
320	};
321
322	inline ostream& operator<<(ostream& out, const prettybyte_t& b)
323	{
324	uint64_t bump_after = 100;
325	if (b.v > bump_after << 60)
326	return out << (b.v >> 60) << " EB";
327	if (b.v > bump_after << 50)
328	return out << (b.v >> 50) << " PB";
329	if (b.v > bump_after << 40)
330	return out << (b.v >> 40) << " TB";
331	if (b.v > bump_after << 30)
332	return out << (b.v >> 30) << " GB";
333	if (b.v > bump_after << 20)
334	return out << (b.v >> 20) << " MB";
335	if (b.v > bump_after << 10)
336	return out << (b.v >> 10) << " kB";
337	return out << b.v << " bytes";
338	}
339
340	struct si_t {
341	uint64_t v;
342	// cppcheck-suppress noExplicitConstructor
343	si_t(uint64_t _v) : v(_v) {}
344	};
345
346	inline ostream& operator<<(ostream& out, const si_t& b)
347	{
348	uint64_t bump_after = 100;
349	if (b.v > bump_after << 60)
350	return out << (b.v >> 60) << "E";
351	if (b.v > bump_after << 50)
352	return out << (b.v >> 50) << "P";
353	if (b.v > bump_after << 40)
354	return out << (b.v >> 40) << "T";
355	if (b.v > bump_after << 30)
356	return out << (b.v >> 30) << "G";
357	if (b.v > bump_after << 20)
358	return out << (b.v >> 20) << "M";
359	if (b.v > bump_after << 10)
360	return out << (b.v >> 10) << "k";
361	return out << b.v;
362	}
363
364	struct pretty_si_t {
365	uint64_t v;
366	// cppcheck-suppress noExplicitConstructor
367	pretty_si_t(uint64_t _v) : v(_v) {}
368	};
369
370	inline ostream& operator<<(ostream& out, const pretty_si_t& b)
371	{
372	uint64_t bump_after = 100;
373	if (b.v > bump_after << 60)
374	return out << (b.v >> 60) << " E";
375	if (b.v > bump_after << 50)
376	return out << (b.v >> 50) << " P";
377	if (b.v > bump_after << 40)
378	return out << (b.v >> 40) << " T";
379	if (b.v > bump_after << 30)
380	return out << (b.v >> 30) << " G";
381	if (b.v > bump_after << 20)
382	return out << (b.v >> 20) << " M";
383	if (b.v > bump_after << 10)
384	return out << (b.v >> 10) << " k";
385	return out << b.v << " ";
386	}
387
388	struct kb_t {
389	uint64_t v;
390	// cppcheck-suppress noExplicitConstructor
391	kb_t(uint64_t _v) : v(_v) {}
392	};
393
394	inline ostream& operator<<(ostream& out, const kb_t& kb)
395	{
396	uint64_t bump_after = 100;
397	if (kb.v > bump_after << 40)
398	return out << (kb.v >> 40) << " PB";
399	if (kb.v > bump_after << 30)
400	return out << (kb.v >> 30) << " TB";
401	if (kb.v > bump_after << 20)
402	return out << (kb.v >> 20) << " GB";
403	if (kb.v > bump_after << 10)
404	return out << (kb.v >> 10) << " MB";
405	return out << kb.v << " kB";
406	}
407
408	inline ostream& operator<<(ostream& out, const ceph_mon_subscribe_item& i)
409	{
410	return out << i.start
411	<< ((i.flags & CEPH_SUBSCRIBE_ONETIME) ? "" : "+");
412	}
413
7c673cae FG	414	struct weightf_t {
	415	float v;
	416	// cppcheck-suppress noExplicitConstructor
	417	weightf_t(float _v) : v(_v) {}
	418	};
	419
	420	inline ostream& operator<<(ostream& out, const weightf_t& w)
	421	{
	422	if (w.v < -0.01) {
	423	return out << "-";
	424	} else if (w.v < 0.000001) {
	425	return out << "0";
	426	} else {
	427	std::streamsize p = out.precision();
	428	return out << std::fixed << std::setprecision(5) << w.v << std::setprecision(p);
	429	}
	430	}
	431
	432	struct shard_id_t {
	433	int8_t id;
	434
	435	shard_id_t() : id(0) {}
	436	explicit shard_id_t(int8_t _id) : id(_id) {}
	437
	438	operator int8_t() const { return id; }
	439
	440	const static shard_id_t NO_SHARD;
	441
	442	void encode(bufferlist &bl) const {
	443	::encode(id, bl);
	444	}
	445	void decode(bufferlist::iterator &bl) {
	446	::decode(id, bl);
	447	}
	448	};
	449	WRITE_CLASS_ENCODER(shard_id_t)
	450	WRITE_EQ_OPERATORS_1(shard_id_t, id)
	451	WRITE_CMP_OPERATORS_1(shard_id_t, id)
	452	ostream &operator<<(ostream &lhs, const shard_id_t &rhs);
	453
31f18b77 FG	454	#if defined(__sun) \|\| defined(_AIX) \|\| defined(DARWIN) \|\| defined(__FreeBSD__)
	455	__s32 ceph_to_hostos_errno(__s32 e);
	456	__s32 hostos_to_ceph_errno(__s32 e);
7c673cae	457	#else
31f18b77 FG	458	#define ceph_to_hostos_errno(e) (e)
31f18b77 FG	459	#define hostos_to_ceph_errno(e) (e)
7c673cae FG	460	#endif
	461
	462	struct errorcode32_t {
	463	int32_t code;
	464
	465	errorcode32_t() : code(0) {}
	466	// cppcheck-suppress noExplicitConstructor
	467	errorcode32_t(int32_t i) : code(i) {}
	468
224ce89b WB	469	operator int() const { return code; }
	470	int* operator&() { return &code; }
	471	int operator==(int i) { return code == i; }
	472	int operator>(int i) { return code > i; }
	473	int operator>=(int i) { return code >= i; }
	474	int operator<(int i) { return code < i; }
	475	int operator<=(int i) { return code <= i; }
7c673cae FG	476
7c673cae FG	477	void encode(bufferlist &bl) const {
31f18b77 FG	478	__s32 newcode = hostos_to_ceph_errno(code);
31f18b77 FG	479	::encode(newcode, bl);
7c673cae FG	480	}
	481	void decode(bufferlist::iterator &bl) {
	482	::decode(code, bl);
31f18b77	483	code = ceph_to_hostos_errno(code);
7c673cae FG	484	}
	485	};
	486	WRITE_CLASS_ENCODER(errorcode32_t)
	487	WRITE_EQ_OPERATORS_1(errorcode32_t, code)
	488	WRITE_CMP_OPERATORS_1(errorcode32_t, code)
	489
	490
	491	#endif