#include "msgr.h"
#include "rados.h"
+/*
+ * Ceph release version
+ */
+#define CEPH_VERSION_MAJOR 0
+#define CEPH_VERSION_MINOR 16
+#define CEPH_VERSION_PATCH 1
+
+#define _CEPH_STRINGIFY(x) #x
+#define CEPH_STRINGIFY(x) _CEPH_STRINGIFY(x)
+#define CEPH_MAKE_VERSION(x, y, z) CEPH_STRINGIFY(x) "." CEPH_STRINGIFY(y) \
+ "." CEPH_STRINGIFY(z)
+#define CEPH_VERSION CEPH_MAKE_VERSION(CEPH_VERSION_MAJOR, \
+ CEPH_VERSION_MINOR, CEPH_VERSION_PATCH)
+
/*
* subprotocol versions. when specific messages types or high-level
* protocols change, bump the affected components. we keep rev
*/
#define CEPH_OSD_PROTOCOL 7 /* cluster internal */
#define CEPH_MDS_PROTOCOL 9 /* cluster internal */
-#define CEPH_MON_PROTOCOL 4 /* cluster internal */
+#define CEPH_MON_PROTOCOL 5 /* cluster internal */
#define CEPH_OSDC_PROTOCOL 20 /* server/client */
-#define CEPH_MDSC_PROTOCOL 28 /* server/client */
-#define CEPH_MONC_PROTOCOL 14 /* server/client */
+#define CEPH_MDSC_PROTOCOL 29 /* server/client */
+#define CEPH_MONC_PROTOCOL 15 /* server/client */
#define CEPH_INO_ROOT 1
#define CEPH_MAX_MON 31
-/*
- * "Frags" are a way to describe a subset of a 32-bit number space,
- * using a mask and a value to match against that mask. Any given frag
- * (subset of the number space) can be partitioned into 2^n sub-frags.
- *
- * Frags are encoded into a 32-bit word:
- * 8 upper bits = "bits"
- * 24 lower bits = "value"
- * (We could go to 5+27 bits, but who cares.)
- *
- * We use the _most_ significant bits of the 24 bit value. This makes
- * values logically sort.
- *
- * Unfortunately, because the "bits" field is still in the high bits, we
- * can't sort encoded frags numerically. However, it does allow you
- * to feed encoded frags as values into frag_contains_value.
- */
-static inline __u32 frag_make(__u32 b, __u32 v)
-{
- return (b << 24) |
- (v & (0xffffffu << (24-b)) & 0xffffffu);
-}
-static inline __u32 frag_bits(__u32 f)
-{
- return f >> 24;
-}
-static inline __u32 frag_value(__u32 f)
-{
- return f & 0xffffffu;
-}
-static inline __u32 frag_mask(__u32 f)
-{
- return (0xffffffu << (24-frag_bits(f))) & 0xffffffu;
-}
-static inline __u32 frag_mask_shift(__u32 f)
-{
- return 24 - frag_bits(f);
-}
-
-static inline int frag_contains_value(__u32 f, __u32 v)
-{
- return (v & frag_mask(f)) == frag_value(f);
-}
-static inline int frag_contains_frag(__u32 f, __u32 sub)
-{
- /* is sub as specific as us, and contained by us? */
- return frag_bits(sub) >= frag_bits(f) &&
- (frag_value(sub) & frag_mask(f)) == frag_value(f);
-}
-
-static inline __u32 frag_parent(__u32 f)
-{
- return frag_make(frag_bits(f) - 1,
- frag_value(f) & (frag_mask(f) << 1));
-}
-static inline int frag_is_left_child(__u32 f)
-{
- return frag_bits(f) > 0 &&
- (frag_value(f) & (0x1000000 >> frag_bits(f))) == 0;
-}
-static inline int frag_is_right_child(__u32 f)
-{
- return frag_bits(f) > 0 &&
- (frag_value(f) & (0x1000000 >> frag_bits(f))) == 1;
-}
-static inline __u32 frag_sibling(__u32 f)
-{
- return frag_make(frag_bits(f),
- frag_value(f) ^ (0x1000000 >> frag_bits(f)));
-}
-static inline __u32 frag_left_child(__u32 f)
-{
- return frag_make(frag_bits(f)+1, frag_value(f));
-}
-static inline __u32 frag_right_child(__u32 f)
-{
- return frag_make(frag_bits(f)+1,
- frag_value(f) | (0x1000000 >> (1+frag_bits(f))));
-}
-static inline __u32 frag_make_child(__u32 f, int by, int i)
-{
- int newbits = frag_bits(f) + by;
- return frag_make(newbits,
- frag_value(f) | (i << (24 - newbits)));
-}
-static inline int frag_is_leftmost(__u32 f)
-{
- return frag_value(f) == 0;
-}
-static inline int frag_is_rightmost(__u32 f)
-{
- return frag_value(f) == frag_mask(f);
-}
-static inline __u32 frag_next(__u32 f)
-{
- return frag_make(frag_bits(f),
- frag_value(f) + (0x1000000 >> frag_bits(f)));
-}
-
-/*
- * comparator to sort frags logically, as when traversing the
- * number space in ascending order...
- */
-static inline int frag_compare(__u32 a, __u32 b)
-{
- unsigned va = frag_value(a);
- unsigned vb = frag_value(b);
- if (va < vb)
- return -1;
- if (va > vb)
- return 1;
- va = frag_bits(a);
- vb = frag_bits(b);
- if (va < vb)
- return -1;
- if (va > vb)
- return 1;
- return 0;
-}
+unsigned int ceph_full_name_hash(const char *name, unsigned int len);
/*
__le32 fl_pg_pool; /* namespace, crush ruleset, rep level */
} __attribute__ ((packed));
-#define ceph_file_layout_su(l) ((__s32)le32_to_cpu((l).fl_stripe_unit))
-#define ceph_file_layout_stripe_count(l) \
- ((__s32)le32_to_cpu((l).fl_stripe_count))
-#define ceph_file_layout_object_size(l) ((__s32)le32_to_cpu((l).fl_object_size))
-#define ceph_file_layout_cas_hash(l) ((__s32)le32_to_cpu((l).fl_cas_hash))
-#define ceph_file_layout_object_su(l) \
- ((__s32)le32_to_cpu((l).fl_object_stripe_unit))
-#define ceph_file_layout_pg_preferred(l) \
- ((__s32)le32_to_cpu((l).fl_pg_preferred))
-#define ceph_file_layout_pg_pool(l) \
- ((__s32)le32_to_cpu((l).fl_pg_pool))
-
-#define ceph_file_layout_stripe_width(l) (le32_to_cpu((l).fl_stripe_unit) * \
- le32_to_cpu((l).fl_stripe_count))
-
-/* "period" == bytes before i start on a new set of objects */
-#define ceph_file_layout_period(l) (le32_to_cpu((l).fl_object_size) * \
- le32_to_cpu((l).fl_stripe_count))
-
-
-
-/*
- * string hash.
- *
- * taken from Linux, tho we should probably take care to use this one
- * in case the upstream hash changes.
- */
-
-/* Name hashing routines. Initial hash value */
-/* Hash courtesy of the R5 hash in reiserfs modulo sign bits */
-#define ceph_init_name_hash() 0
-
-/* partial hash update function. Assume roughly 4 bits per character */
-static inline unsigned long
-ceph_partial_name_hash(unsigned long c, unsigned long prevhash)
-{
- return (prevhash + (c << 4) + (c >> 4)) * 11;
-}
-
-/*
- * Finally: cut down the number of bits to a int value (and try to avoid
- * losing bits)
- */
-static inline unsigned long ceph_end_name_hash(unsigned long hash)
-{
- return (unsigned int) hash;
-}
-
-/* Compute the hash for a name string. */
-static inline unsigned int
-ceph_full_name_hash(const char *name, unsigned int len)
-{
- unsigned long hash = ceph_init_name_hash();
- while (len--)
- hash = ceph_partial_name_hash(*name++, hash);
- return ceph_end_name_hash(hash);
-}
+#define CEPH_MIN_STRIPE_UNIT 65536
+int ceph_file_layout_is_valid(const struct ceph_file_layout *layout);
/*********************************************
#define CEPH_MSG_MON_GET_MAP 5
#define CEPH_MSG_CLIENT_MOUNT 10
#define CEPH_MSG_CLIENT_MOUNT_ACK 11
-#define CEPH_MSG_CLIENT_UNMOUNT 12
#define CEPH_MSG_STATFS 13
#define CEPH_MSG_STATFS_REPLY 14
+#define CEPH_MSG_MON_SUBSCRIBE 15
+#define CEPH_MSG_MON_SUBSCRIBE_ACK 16
/* client <-> mds */
-#define CEPH_MSG_MDS_GETMAP 20
#define CEPH_MSG_MDS_MAP 21
#define CEPH_MSG_CLIENT_SESSION 22
#define CEPH_MSG_CLIENT_CAPRELEASE 0x313
/* osd */
-#define CEPH_MSG_OSD_GETMAP 40
#define CEPH_MSG_OSD_MAP 41
#define CEPH_MSG_OSD_OP 42
#define CEPH_MSG_OSD_OPREPLY 43
+struct ceph_mon_request_header {
+ __le64 have_version;
+ __le16 session_mon;
+ __le64 session_mon_tid;
+} __attribute__ ((packed));
struct ceph_mon_statfs {
- __le64 have_version;
- ceph_fsid_t fsid;
+ struct ceph_mon_request_header monhdr;
+ struct ceph_fsid fsid;
__le64 tid;
} __attribute__ ((packed));
} __attribute__ ((packed));
struct ceph_mon_statfs_reply {
- ceph_fsid_t fsid;
+ struct ceph_fsid fsid;
__le64 tid;
__le64 version;
struct ceph_statfs st;
} __attribute__ ((packed));
struct ceph_osd_getmap {
- __le64 have_version;
- ceph_fsid_t fsid;
+ struct ceph_mon_request_header monhdr;
+ struct ceph_fsid fsid;
__le32 start;
} __attribute__ ((packed));
struct ceph_mds_getmap {
- __le64 have_version;
- ceph_fsid_t fsid;
+ struct ceph_mon_request_header monhdr;
+ struct ceph_fsid fsid;
} __attribute__ ((packed));
struct ceph_client_mount {
- __le64 have_version;
+ struct ceph_mon_request_header monhdr;
} __attribute__ ((packed));
-struct ceph_client_unmount {
- __le64 have_version;
+struct ceph_mon_subscribe_item {
+ __le64 have_version; __le64 have;
+ __u8 onetime;
} __attribute__ ((packed));
/*
#define CEPH_MDS_STATE_BOOT -4 /* up, boot announcement. */
#define CEPH_MDS_STATE_STANDBY -5 /* up, idle. waiting for assignment. */
#define CEPH_MDS_STATE_CREATING -6 /* up, creating MDS instance. */
-#define CEPH_MDS_STATE_STARTING -7 /* up, starting previously stopped mds. */
+#define CEPH_MDS_STATE_STARTING -7 /* up, starting previously stopped mds */
#define CEPH_MDS_STATE_STANDBY_REPLAY -8 /* up, tailing active node's journal */
#define CEPH_MDS_STATE_REPLAY 8 /* up, replaying journal. */
#define CEPH_MDS_STATE_ACTIVE 13 /* up, active */
#define CEPH_MDS_STATE_STOPPING 14 /* up, but exporting metadata */
-static inline const char *ceph_mds_state_name(int s)
-{
- switch (s) {
- /* down and out */
- case CEPH_MDS_STATE_DNE: return "down:dne";
- case CEPH_MDS_STATE_STOPPED: return "down:stopped";
- /* up and out */
- case CEPH_MDS_STATE_BOOT: return "up:boot";
- case CEPH_MDS_STATE_STANDBY: return "up:standby";
- case CEPH_MDS_STATE_STANDBY_REPLAY: return "up:standby-replay";
- case CEPH_MDS_STATE_CREATING: return "up:creating";
- case CEPH_MDS_STATE_STARTING: return "up:starting";
- /* up and in */
- case CEPH_MDS_STATE_REPLAY: return "up:replay";
- case CEPH_MDS_STATE_RESOLVE: return "up:resolve";
- case CEPH_MDS_STATE_RECONNECT: return "up:reconnect";
- case CEPH_MDS_STATE_REJOIN: return "up:rejoin";
- case CEPH_MDS_STATE_CLIENTREPLAY: return "up:clientreplay";
- case CEPH_MDS_STATE_ACTIVE: return "up:active";
- case CEPH_MDS_STATE_STOPPING: return "up:stopping";
- default: return "";
- }
- return NULL;
-}
+extern const char *ceph_mds_state_name(int s);
/*
CEPH_SESSION_RECALL_STATE,
};
-static inline const char *ceph_session_op_name(int op)
-{
- switch (op) {
- case CEPH_SESSION_REQUEST_OPEN: return "request_open";
- case CEPH_SESSION_OPEN: return "open";
- case CEPH_SESSION_REQUEST_CLOSE: return "request_close";
- case CEPH_SESSION_CLOSE: return "close";
- case CEPH_SESSION_REQUEST_RENEWCAPS: return "request_renewcaps";
- case CEPH_SESSION_RENEWCAPS: return "renewcaps";
- case CEPH_SESSION_STALE: return "stale";
- case CEPH_SESSION_RECALL_STATE: return "recall_state";
- default: return "???";
- }
-}
+extern const char *ceph_session_op_name(int op);
struct ceph_mds_session_head {
__le32 op;
CEPH_MDS_OP_LSSNAP = 0x00402,
};
-static inline const char *ceph_mds_op_name(int op)
-{
- switch (op) {
- case CEPH_MDS_OP_LOOKUP: return "lookup";
- case CEPH_MDS_OP_LOOKUPHASH: return "lookuphash";
- case CEPH_MDS_OP_LOOKUPPARENT: return "lookupparent";
- case CEPH_MDS_OP_GETATTR: return "getattr";
- case CEPH_MDS_OP_SETXATTR: return "setxattr";
- case CEPH_MDS_OP_SETATTR: return "setattr";
- case CEPH_MDS_OP_RMXATTR: return "rmxattr";
- case CEPH_MDS_OP_READDIR: return "readdir";
- case CEPH_MDS_OP_MKNOD: return "mknod";
- case CEPH_MDS_OP_LINK: return "link";
- case CEPH_MDS_OP_UNLINK: return "unlink";
- case CEPH_MDS_OP_RENAME: return "rename";
- case CEPH_MDS_OP_MKDIR: return "mkdir";
- case CEPH_MDS_OP_RMDIR: return "rmdir";
- case CEPH_MDS_OP_SYMLINK: return "symlink";
- case CEPH_MDS_OP_CREATE: return "create";
- case CEPH_MDS_OP_OPEN: return "open";
- case CEPH_MDS_OP_LOOKUPSNAP: return "lookupsnap";
- case CEPH_MDS_OP_LSSNAP: return "lssnap";
- case CEPH_MDS_OP_MKSNAP: return "mksnap";
- case CEPH_MDS_OP_RMSNAP: return "rmsnap";
- default: return "???";
- }
-}
+extern const char *ceph_mds_op_name(int op);
+
#define CEPH_SETATTR_MODE 1
#define CEPH_SETATTR_UID 2
union ceph_mds_request_args {
struct {
- __le32 mask; /* CEPH_CAP_* */
+ __le32 mask; /* CEPH_CAP_* */
} __attribute__ ((packed)) getattr;
struct {
__le32 mode;
__le32 gid;
struct ceph_timespec mtime;
struct ceph_timespec atime;
- __le64 size, old_size;
- __le32 mask; /* CEPH_SETATTR_* */
+ __le64 size, old_size; /* old_size needed by truncate */
+ __le32 mask; /* CEPH_SETATTR_* */
} __attribute__ ((packed)) setattr;
struct {
- __le32 frag;
- __le32 max_entries;
+ __le32 frag; /* which dir fragment */
+ __le32 max_entries; /* how many dentries to grab */
} __attribute__ ((packed)) readdir;
struct {
__le32 mode;
struct {
__le32 flags;
__le32 mode;
+ __le32 stripe_unit; /* layout for newly created file */
+ __le32 stripe_count; /* ... */
+ __le32 object_size;
+ __le32 file_replication;
+ __le32 preferred;
} __attribute__ ((packed)) open;
struct {
__le32 flags;
struct ceph_mds_request_head {
__le64 tid, oldest_client_tid;
- __le32 mdsmap_epoch; /* on client */
- __le32 flags;
- __u8 num_retry, num_fwd;
- __le16 num_releases;
- __le32 op;
+ __le32 mdsmap_epoch; /* on client */
+ __le32 flags; /* CEPH_MDS_FLAG_* */
+ __u8 num_retry, num_fwd; /* count retry, fwd attempts */
+ __le16 num_releases; /* # include cap/lease release records */
+ __le32 op; /* mds op code */
__le32 caller_uid, caller_gid;
- __le64 ino; /* use this ino for openc, mkdir, mknod, etc. */
+ __le64 ino; /* use this ino for openc, mkdir, mknod,
+ etc. (if replaying) */
union ceph_mds_request_args args;
} __attribute__ ((packed));
+/* cap/lease release record */
struct ceph_mds_request_release {
- __le64 ino, cap_id;
- __le32 caps, wanted;
+ __le64 ino, cap_id; /* ino and unique cap id */
+ __le32 caps, wanted; /* new issued, wanted */
__le32 seq, issue_seq, mseq;
- __le32 dname_seq;
- __le32 dname_len; /* if releasing a dentry lease; string follows. */
+ __le32 dname_seq; /* if releasing a dentry lease, a */
+ __le32 dname_len; /* string follows. */
} __attribute__ ((packed));
/* client reply */
__le32 op;
__le32 result;
__le32 mdsmap_epoch;
- __u8 safe;
- __u8 is_dentry, is_target;
+ __u8 safe; /* true if committed to disk */
+ __u8 is_dentry, is_target; /* true if dentry, target inode records
+ are included with reply */
} __attribute__ ((packed));
/* one for each node split */
struct ceph_frag_tree_split {
- __le32 frag; /* this frag splits... */
- __le32 by; /* ...by this many bits */
+ __le32 frag; /* this frag splits... */
+ __le32 by; /* ...by this many bits */
} __attribute__ ((packed));
struct ceph_frag_tree_head {
- __le32 nsplits;
+ __le32 nsplits; /* num ceph_frag_tree_split records */
struct ceph_frag_tree_split splits[];
} __attribute__ ((packed));
+/* capability issue, for bundling with mds reply */
struct ceph_mds_reply_cap {
- __le32 caps, wanted;
+ __le32 caps, wanted; /* caps issued, wanted */
__le64 cap_id;
__le32 seq, mseq;
- __le64 realm;
- __le32 ttl_ms; /* ttl, in ms. if readonly and unwanted. */
- __u8 flags;
+ __le64 realm; /* snap realm */
+ __u8 flags; /* CEPH_CAP_FLAG_* */
} __attribute__ ((packed));
-#define CEPH_CAP_FLAG_AUTH 1
+#define CEPH_CAP_FLAG_AUTH 1 /* cap is issued by auth mds */
+/* inode record, for bundling with mds reply */
struct ceph_mds_reply_inode {
__le64 ino;
__le64 snapid;
__le32 rdev;
- __le64 version;
- struct ceph_mds_reply_cap cap;
+ __le64 version; /* inode version */
+ __le64 xattr_version; /* version for xattr blob */
+ struct ceph_mds_reply_cap cap; /* caps issued for this inode */
struct ceph_file_layout layout;
struct ceph_timespec ctime, mtime, atime;
__le32 time_warp_seq;
__le32 nlink;
__le64 files, subdirs, rbytes, rfiles, rsubdirs; /* dir stats */
struct ceph_timespec rctime;
- __le64 xattr_version;
- struct ceph_frag_tree_head fragtree;
+ struct ceph_frag_tree_head fragtree; /* (must be at end of struct) */
} __attribute__ ((packed));
/* followed by frag array, then symlink string, then xattr blob */
/* reply_lease follows dname, and reply_inode */
struct ceph_mds_reply_lease {
- __le16 mask;
- __le32 duration_ms;
+ __le16 mask; /* lease type(s) */
+ __le32 duration_ms; /* lease duration */
__le32 seq;
} __attribute__ ((packed));
struct ceph_mds_reply_dirfrag {
- __le32 frag; /* fragment */
- __le32 auth; /* auth mds, if this is a delegation point */
- __le32 ndist; /* number of mds' this is replicated on */
+ __le32 frag; /* fragment */
+ __le32 auth; /* auth mds, if this is a delegation point */
+ __le32 ndist; /* number of mds' this is replicated on */
__le32 dist[];
} __attribute__ ((packed));
#define CEPH_FILE_MODE_LAZY 4 /* lazy io */
#define CEPH_FILE_MODE_NUM 8 /* bc these are bit fields.. mostly */
-static inline int ceph_flags_to_mode(int flags)
-{
-#ifdef O_DIRECTORY /* fixme */
- if ((flags & O_DIRECTORY) == O_DIRECTORY)
- return CEPH_FILE_MODE_PIN;
-#endif
-#ifdef O_LAZY
- if (flags & O_LAZY)
- return CEPH_FILE_MODE_LAZY;
-#endif
- if ((flags & O_APPEND) == O_APPEND)
- flags |= O_WRONLY;
-
- flags &= O_ACCMODE;
- if ((flags & O_RDWR) == O_RDWR)
- return CEPH_FILE_MODE_RDWR;
- if ((flags & O_WRONLY) == O_WRONLY)
- return CEPH_FILE_MODE_WR;
- return CEPH_FILE_MODE_RD;
-}
+int ceph_flags_to_mode(int flags);
/* capability bits */
CEPH_CAP_LINK_SHARED | \
CEPH_CAP_XATTR_SHARED | \
CEPH_CAP_FILE_SHARED)
-#define CEPH_CAP_ANY_RD (CEPH_CAP_ANY_SHARED | CEPH_CAP_FILE_RD | \
+#define CEPH_CAP_ANY_RD (CEPH_CAP_ANY_SHARED | CEPH_CAP_FILE_RD | \
CEPH_CAP_FILE_CACHE)
#define CEPH_CAP_ANY_EXCL (CEPH_CAP_AUTH_EXCL | \
#define CEPH_CAP_LOCKS (CEPH_LOCK_IFILE | CEPH_LOCK_IAUTH | CEPH_LOCK_ILINK | \
CEPH_LOCK_IXATTR)
-static inline int ceph_caps_for_mode(int mode)
-{
- switch (mode) {
- case CEPH_FILE_MODE_PIN:
- return CEPH_CAP_PIN;
- case CEPH_FILE_MODE_RD:
- return CEPH_CAP_PIN | CEPH_CAP_FILE_SHARED |
- CEPH_CAP_FILE_RD | CEPH_CAP_FILE_CACHE;
- case CEPH_FILE_MODE_RDWR:
- return CEPH_CAP_PIN | CEPH_CAP_FILE_SHARED |
- CEPH_CAP_FILE_EXCL |
- CEPH_CAP_FILE_RD | CEPH_CAP_FILE_CACHE |
- CEPH_CAP_FILE_WR | CEPH_CAP_FILE_BUFFER |
- CEPH_CAP_AUTH_SHARED | CEPH_CAP_AUTH_EXCL |
- CEPH_CAP_XATTR_SHARED | CEPH_CAP_XATTR_EXCL;
- case CEPH_FILE_MODE_WR:
- return CEPH_CAP_PIN | CEPH_CAP_FILE_SHARED |
- CEPH_CAP_FILE_EXCL |
- CEPH_CAP_FILE_WR | CEPH_CAP_FILE_BUFFER |
- CEPH_CAP_AUTH_SHARED | CEPH_CAP_AUTH_EXCL |
- CEPH_CAP_XATTR_SHARED | CEPH_CAP_XATTR_EXCL;
- }
- return 0;
-}
+int ceph_caps_for_mode(int mode);
enum {
- CEPH_CAP_OP_GRANT, /* mds->client grant */
- CEPH_CAP_OP_REVOKE, /* mds->client revoke */
- CEPH_CAP_OP_TRUNC, /* mds->client trunc notify */
- CEPH_CAP_OP_EXPORT, /* mds has exported the cap */
- CEPH_CAP_OP_IMPORT, /* mds has imported the cap from specified mds */
- CEPH_CAP_OP_UPDATE, /* client->mds update */
- CEPH_CAP_OP_DROP, /* client->mds drop cap bits */
- CEPH_CAP_OP_FLUSH, /* client->mds cap writeback */
- CEPH_CAP_OP_FLUSH_ACK, /* mds->client flushed */
- CEPH_CAP_OP_FLUSHSNAP, /* client->mds flush snapped metadata */
+ CEPH_CAP_OP_GRANT, /* mds->client grant */
+ CEPH_CAP_OP_REVOKE, /* mds->client revoke */
+ CEPH_CAP_OP_TRUNC, /* mds->client trunc notify */
+ CEPH_CAP_OP_EXPORT, /* mds has exported the cap */
+ CEPH_CAP_OP_IMPORT, /* mds has imported the cap */
+ CEPH_CAP_OP_UPDATE, /* client->mds update */
+ CEPH_CAP_OP_DROP, /* client->mds drop cap bits */
+ CEPH_CAP_OP_FLUSH, /* client->mds cap writeback */
+ CEPH_CAP_OP_FLUSH_ACK, /* mds->client flushed */
+ CEPH_CAP_OP_FLUSHSNAP, /* client->mds flush snapped metadata */
CEPH_CAP_OP_FLUSHSNAP_ACK, /* mds->client flushed snapped metadata */
- CEPH_CAP_OP_RELEASE, /* client->mds release (clean) cap */
- CEPH_CAP_OP_RENEW, /* client->mds renewal request */
+ CEPH_CAP_OP_RELEASE, /* client->mds release (clean) cap */
+ CEPH_CAP_OP_RENEW, /* client->mds renewal request */
};
-static inline const char *ceph_cap_op_name(int op)
-{
- switch (op) {
- case CEPH_CAP_OP_GRANT: return "grant";
- case CEPH_CAP_OP_REVOKE: return "revoke";
- case CEPH_CAP_OP_TRUNC: return "trunc";
- case CEPH_CAP_OP_EXPORT: return "export";
- case CEPH_CAP_OP_IMPORT: return "import";
- case CEPH_CAP_OP_UPDATE: return "update";
- case CEPH_CAP_OP_DROP: return "drop";
- case CEPH_CAP_OP_FLUSH: return "flush";
- case CEPH_CAP_OP_FLUSH_ACK: return "flush_ack";
- case CEPH_CAP_OP_FLUSHSNAP: return "flushsnap";
- case CEPH_CAP_OP_FLUSHSNAP_ACK: return "flushsnap_ack";
- case CEPH_CAP_OP_RELEASE: return "release";
- case CEPH_CAP_OP_RENEW: return "renew";
- default: return "???";
- }
-}
+extern const char *ceph_cap_op_name(int op);
/*
* caps message, used for capability callbacks, acks, requests, etc.
*/
struct ceph_mds_caps {
- __le32 op;
+ __le32 op; /* CEPH_CAP_OP_* */
__le64 ino, realm;
__le64 cap_id;
__le32 seq, issue_seq;
- __le32 caps, wanted, dirty;
+ __le32 caps, wanted, dirty; /* latest issued/wanted/dirty */
__le32 migrate_seq;
__le64 snap_follows;
__le32 snap_trace_len;
- __le32 ttl_ms; /* for IMPORT op only */
- __le64 client_tid; /* for FLUSH(SNAP) -> FLUSH(SNAP)_ACK */
+ __le64 client_tid; /* for FLUSH(SNAP) -> FLUSH(SNAP)_ACK */
/* authlock */
__le32 uid, gid, mode;
__le32 time_warp_seq;
} __attribute__ ((packed));
+/* cap release msg head */
struct ceph_mds_cap_release {
- __le32 num;
+ __le32 num; /* number of cap_items that follow */
} __attribute__ ((packed));
struct ceph_mds_cap_item {
#define CEPH_MDS_LEASE_RENEW 3 /* client <-> mds */
#define CEPH_MDS_LEASE_REVOKE_ACK 4 /* client -> mds */
-static inline const char *ceph_lease_op_name(int o)
-{
- switch (o) {
- case CEPH_MDS_LEASE_REVOKE: return "revoke";
- case CEPH_MDS_LEASE_RELEASE: return "release";
- case CEPH_MDS_LEASE_RENEW: return "renew";
- case CEPH_MDS_LEASE_REVOKE_ACK: return "revoke_ack";
- default: return "???";
- }
-}
+extern const char *ceph_lease_op_name(int o);
+/* lease msg header */
struct ceph_mds_lease {
- __u8 action;
- __le16 mask;
+ __u8 action; /* CEPH_MDS_LEASE_* */
+ __le16 mask; /* which lease */
__le64 ino;
- __le64 first, last;
+ __le64 first, last; /* snap range */
__le32 seq;
- __le32 duration_ms; /* duration of renewal */
+ __le32 duration_ms; /* duration of renewal */
} __attribute__ ((packed));
/* followed by a __le32+string for dname */
-
/* client reconnect */
struct ceph_mds_cap_reconnect {
__le64 cap_id;
__le64 size;
struct ceph_timespec mtime, atime;
__le64 snaprealm;
- __le64 pathbase;
+ __le64 pathbase; /* base ino for our path to this ino */
} __attribute__ ((packed));
/* followed by encoded string */
struct ceph_mds_snaprealm_reconnect {
- __le64 ino;
- __le64 seq;
+ __le64 ino; /* snap realm base */
+ __le64 seq; /* snap seq for this snap realm */
__le64 parent; /* parent realm */
} __attribute__ ((packed));
CEPH_SNAP_OP_SPLIT,
};
-static inline const char *ceph_snap_op_name(int o)
-{
- switch (o) {
- case CEPH_SNAP_OP_UPDATE: return "update";
- case CEPH_SNAP_OP_CREATE: return "create";
- case CEPH_SNAP_OP_DESTROY: return "destroy";
- case CEPH_SNAP_OP_SPLIT: return "split";
- default: return "???";
- }
-}
+extern const char *ceph_snap_op_name(int o);
+/* snap msg header */
struct ceph_mds_snap_head {
- __le32 op;
- __le64 split;
- __le32 num_split_inos;
- __le32 num_split_realms;
- __le32 trace_len;
+ __le32 op; /* CEPH_SNAP_OP_* */
+ __le64 split; /* ino to split off, if any */
+ __le32 num_split_inos; /* # inos belonging to new child realm */
+ __le32 num_split_realms; /* # child realms udner new child realm */
+ __le32 trace_len; /* size of snap trace blob */
} __attribute__ ((packed));
/* followed by split ino list, then split realms, then the trace blob */
* whenever the wire protocol changes. try to keep this string length
* constant.
*/
-#define CEPH_BANNER "ceph 014\n"
+#define CEPH_BANNER "ceph v022"
#define CEPH_BANNER_MAX_LEN 30
* network, e.g. 'mds0' or 'osd3'.
*/
struct ceph_entity_name {
- __le32 type;
- __le32 num;
+ __u8 type; /* CEPH_ENTITY_TYPE_* */
+ __le64 num;
} __attribute__ ((packed));
#define CEPH_ENTITY_TYPE_MON 1
struct ceph_entity_addr {
__le32 erank; /* entity's rank in process */
__le32 nonce; /* unique id for process (e.g. pid) */
- struct sockaddr_in ipaddr;
+ struct sockaddr_storage in_addr;
} __attribute__ ((packed));
static inline bool ceph_entity_addr_is_local(const struct ceph_entity_addr *a,
const struct ceph_entity_addr *b)
{
return a->nonce == b->nonce &&
- a->ipaddr.sin_addr.s_addr == b->ipaddr.sin_addr.s_addr;
+ memcmp(&a->in_addr, &b->in_addr, sizeof(a->in_addr)) == 0;
}
static inline bool ceph_entity_addr_equal(const struct ceph_entity_addr *a,
#define CEPH_MSGR_TAG_RETRY_GLOBAL 5 /* server->client + gseq: try again
with higher gseq */
#define CEPH_MSGR_TAG_CLOSE 6 /* closing pipe */
-#define CEPH_MSGR_TAG_MSG 10 /* message */
-#define CEPH_MSGR_TAG_ACK 11 /* message ack */
+#define CEPH_MSGR_TAG_MSG 7 /* message */
+#define CEPH_MSGR_TAG_ACK 8 /* message ack */
+#define CEPH_MSGR_TAG_KEEPALIVE 9 /* just a keepalive byte! */
+#define CEPH_MSGR_TAG_BADPROTOVER 10 /* bad protocol version */
/*
* connection negotiation
*/
struct ceph_msg_connect {
- __le32 host_type; /* CEPH_ENTITY_TYPE_* */
- __le32 global_seq;
- __le32 connect_seq;
- __u8 flags;
+ __le32 host_type; /* CEPH_ENTITY_TYPE_* */
+ __le32 global_seq; /* count connections initiated by this host */
+ __le32 connect_seq; /* count connections initiated in this session */
+ __le32 protocol_version;
+ __u8 flags; /* CEPH_MSG_CONNECT_* */
} __attribute__ ((packed));
struct ceph_msg_connect_reply {
__u8 tag;
__le32 global_seq;
__le32 connect_seq;
+ __le32 protocol_version;
__u8 flags;
} __attribute__ ((packed));
__le64 seq; /* message seq# for this session */
__le16 type; /* message type */
__le16 priority; /* priority. higher value == higher priority */
+ __le16 version; /* version of message encoding */
__le32 front_len; /* bytes in main payload */
__le32 middle_len;/* bytes in middle payload */
__le16 data_off; /* sender: include full offset;
receiver: mask against ~PAGE_MASK */
- __u8 mon_protocol, monc_protocol; /* protocol versions, */
- __u8 osd_protocol, osdc_protocol; /* internal and public */
- __u8 mds_protocol, mdsc_protocol;
-
- struct ceph_entity_inst src, orig_src, dst;
+ struct ceph_entity_inst src, orig_src;
+ __le32 dst_erank;
__le32 crc; /* header crc32c */
} __attribute__ ((packed));
* follows data payload
*/
struct ceph_msg_footer {
- __le32 flags;
__le32 front_crc, middle_crc, data_crc;
+ __u8 flags;
} __attribute__ ((packed));
-#define CEPH_MSG_FOOTER_ABORTED (1<<0) /* drop this message */
+#define CEPH_MSG_FOOTER_COMPLETE (1<<0) /* msg wasn't aborted */
#define CEPH_MSG_FOOTER_NOCRC (1<<1) /* no data crc */
#include <epan/packet.h>\r
#include <epan/dissectors/packet-tcp.h>\r
\r
-// this is needed for ceph_fs to compile in userland\r
-#ifdef _MSC_VER\r
-typedef char __s8;\r
-typedef short __s16;\r
-typedef int __s32;\r
-typedef __int64 __s64;\r
-typedef unsigned char __u8;\r
-typedef unsigned short __u16;\r
-typedef unsigned int __u32;\r
-typedef unsigned __int64 __u64;\r
-typedef __u16 __le16;\r
-typedef __u32 __le32;\r
-typedef __u64 __le64;\r
-#define __attribute__(x)\r
-#define O_ACCMODE (O_RDONLY | O_RDWR | O_WRONLY)\r
-#include <winsock.h>\r
-#else\r
-#include <netinet/in.h>\r
-#include <linux/types.h>\r
-#endif\r
-typedef int bool;\r
-\r
-#define le16_to_cpu(x) (x)\r
-#define le32_to_cpu(x) (x)\r
-#define le64_to_cpu(x) (x)\r
-\r
-typedef guint32 uint32_t;\r
-\r
-#include <fcntl.h>\r
-#include <string.h>\r
-\r
-#ifdef _MSC_VER\r
-#pragma pack(1)\r
-#endif\r
-#include "ceph_fs.h"\r
-#ifdef _MSC_VER\r
-#pragma pack()\r
-#endif\r
+#include "types.h"\r
\r
#include "crc32c.h"\r
\r
-\r
-\r
#include <string.h>\r
\r
#define PROTO_TAG_CEPH "CEPH"\r
{ 0, NULL }\r
}; \r
\r
-#define ACK_MSG_SIZE 5\r
+#define ACK_MSG_SIZE 9\r
#define TVB_MSG_HEADER_POS(x) (1 + offsetof(struct ceph_msg_header, x))\r
#define TVB_IS_ACK(ofs) (tvb_get_guint8(tvb, ofs) == CEPH_MSGR_TAG_ACK)\r
#define TVB_MSG_FIELD(func, tvb, ofs, field) func(tvb, ofs + (TVB_IS_ACK(ofs) ? ACK_MSG_SIZE : 0) + TVB_MSG_HEADER_POS(field))\r
static gint hf_ceph_hdr_seq = -1;\r
static gint hf_ceph_hdr_type = -1;\r
static gint hf_ceph_hdr_priority = -1;\r
+static gint hf_ceph_hdr_version = -1;\r
static gint hf_ceph_hdr_mon_protocol = -1;\r
static gint hf_ceph_hdr_osd_protocol = -1;\r
static gint hf_ceph_hdr_mds_protocol = -1;\r
{ "tag", "ceph.tag", FT_UINT8, BASE_DEC, NULL, 0x0,\r
"hdr: tag", HFILL }},\r
{ &hf_ceph_hdr_seq_ack,\r
- { "ack seq", "ceph.ack.seq", FT_UINT32, BASE_DEC, NULL, 0x0,\r
+ { "ack seq", "ceph.ack.seq", FT_UINT64, BASE_DEC, NULL, 0x0,\r
"ack: seq", HFILL }},\r
{ &hf_ceph_hdr_seq,\r
{ "seq", "ceph.seq", FT_UINT64, BASE_DEC, NULL, 0x0,\r
{ &hf_ceph_hdr_priority,\r
{ "priority", "ceph.priority", FT_UINT16, BASE_DEC, NULL, 0x0,\r
"hdr: priority", HFILL }},\r
+ { &hf_ceph_hdr_version,\r
+ { "version", "ceph.version", FT_UINT16, BASE_DEC, NULL, 0x0,\r
+ "hdr: version", HFILL }},\r
{ &hf_ceph_hdr_mon_protocol,\r
{ "mon_protocol", "ceph.mon_protocol", FT_UINT16, BASE_DEC, NULL, 0x0,\r
"hdr: mon_protocol", HFILL }},\r
proto_tree *ceph_banner_tree = NULL;\r
proto_item *ceph_sub_item = NULL;\r
\r
- ceph_sub_item = proto_tree_add_item( tree, hf_ceph_banner, tvb, offset, 8, TRUE );\r
+ ceph_sub_item = proto_tree_add_item( tree, hf_ceph_banner, tvb, offset, 9, TRUE );\r
ceph_banner_tree = proto_item_add_subtree(ceph_sub_item, ett_ceph);\r
\r
proto_tree_add_item(ceph_banner_tree, hf_ceph_banner_magic, tvb, offset, 4, TRUE);\r
- proto_tree_add_item(ceph_banner_tree, hf_ceph_banner_version, tvb, offset+4, 4, TRUE);\r
+ proto_tree_add_item(ceph_banner_tree, hf_ceph_banner_version, tvb, offset+5, 4, TRUE);\r
\r
return offset+9;\r
}\r
ceph_entity_tree = proto_item_add_subtree(ceph_sub_item, ett_ceph);\r
proto_tree_add_item(ceph_entity_tree, hf_ceph_connect_erank, tvb, offset, 4, TRUE);\r
proto_tree_add_item(ceph_entity_tree, hf_ceph_connect_nonce, tvb, offset+4, 4, TRUE);\r
- offset = dissect_sockaddr_in(tvb, ceph_entity_tree, offset+8);\r
+ dissect_sockaddr_in(tvb, ceph_entity_tree, offset+8);\r
#if 0\r
proto_tree_add_item(ceph_entity_tree, hf_ceph_connect_host_type, tvb, offset, 4, TRUE);\r
offset += 4;\r
#endif\r
\r
- return offset;\r
+ return offset + sizeof(struct ceph_entity_addr);\r
}\r
\r
static guint32 dissect_ceph_fsid(tvbuff_t *tvb, proto_tree *tree, guint32 offset)\r
{\r
proto_tree *ceph_entity_tree = NULL;\r
proto_item *ceph_sub_item = NULL;\r
- ceph_fsid_t *fsid;\r
+ struct ceph_fsid *fsid;\r
\r
- fsid = (ceph_fsid_t *)tvb_get_ptr(tvb, offset, sizeof(ceph_fsid_t));\r
+ fsid = (struct ceph_fsid *)tvb_get_ptr(tvb, offset, sizeof(struct ceph_fsid));\r
\r
ceph_sub_item = proto_tree_add_item( tree, hf_ceph_fsid, tvb, offset, sizeof(struct ceph_entity_addr), TRUE );\r
ceph_entity_tree = proto_item_add_subtree(ceph_sub_item, ett_ceph);\r
proto_tree_add_item(ceph_entity_tree, hf_ceph_connect_nonce, tvb, offset+4, 4, TRUE);\r
\r
proto_tree_add_text(tree, tvb, 0, \r
- sizeof(ceph_fsid_t), "fsid: " FMT_INO "." FMT_INO, ((unsigned long long *)fsid->fsid)[0], ((unsigned long long *)fsid->fsid)[1]);\r
+ sizeof(struct ceph_fsid), "fsid: " FMT_INO "." FMT_INO, ((unsigned long long *)fsid->fsid)[0], ((unsigned long long *)fsid->fsid)[1]);\r
\r
- offset += sizeof(ceph_fsid_t);\r
+ offset += sizeof(struct ceph_fsid);\r
\r
return offset;\r
}\r
proto_tree *ceph_header_tree = NULL;\r
proto_item *ceph_sub_item = NULL;\r
proto_item *ceph_item = proto_tree_get_parent(tree);\r
+ struct ceph_msg_connect *msg;\r
\r
offset = dissect_ceph_banner(tvb, tree, offset);\r
\r
ceph_header_tree = proto_item_add_subtree(ceph_sub_item, ett_ceph);\r
\r
offset = dissect_ceph_entity_addr(tvb, ceph_header_tree, offset);\r
+#if 0\r
proto_tree_add_item(ceph_header_tree, hf_ceph_connect_host_type, tvb, offset, 4, TRUE);\r
offset += 4;\r
proto_tree_add_item(ceph_header_tree, hf_ceph_connect_global_seq, tvb, offset, 4, TRUE);\r
proto_tree_add_item(ceph_header_tree, hf_ceph_connect_connect_seq, tvb, offset+4, 4, TRUE);\r
proto_tree_add_item(ceph_header_tree, hf_ceph_connect_flags, tvb, offset+8, 1, TRUE);\r
offset += 8;\r
+#endif\r
+\r
+ msg = (struct ceph_msg_connect *)tvb_get_ptr(tvb, offset, sizeof(struct ceph_msg_connect));\r
+ PROTO_ADD_TEXT(struct ceph_msg_connect, msg, host_type, "%d");\r
+ PROTO_ADD_TEXT(struct ceph_msg_connect, msg, global_seq, "%d");\r
+ PROTO_ADD_TEXT(struct ceph_msg_connect, msg, connect_seq, "%d");\r
+ PROTO_ADD_TEXT(struct ceph_msg_connect, msg, protocol_version, "%d");\r
+ PROTO_ADD_TEXT(struct ceph_msg_connect, msg, flags, "%x");\r
+\r
return offset;\r
}\r
\r
proto_tree *ceph_header_tree = NULL;\r
proto_item *ceph_sub_item = NULL;\r
proto_item *ceph_item = proto_tree_get_parent(tree);\r
+ struct ceph_msg_connect_reply *msg;\r
\r
offset = dissect_ceph_banner(tvb, tree, offset);\r
\r
\r
offset = dissect_ceph_entity_addr(tvb, ceph_header_tree, offset);\r
\r
- proto_tree_add_item(ceph_header_tree, hf_ceph_hdr_tag, tvb, offset, 1, TRUE);\r
- offset += 1;\r
- proto_tree_add_item(ceph_header_tree, hf_ceph_connect_global_seq, tvb, offset, 4, TRUE);\r
- proto_tree_add_item(ceph_header_tree, hf_ceph_connect_connect_seq, tvb, offset+4, 4, TRUE);\r
- proto_tree_add_item(ceph_header_tree, hf_ceph_connect_flags, tvb, offset+8, 1, TRUE);\r
+ msg = (struct ceph_msg_connect_reply *)tvb_get_ptr(tvb, offset, sizeof(struct ceph_msg_connect_reply));\r
+ PROTO_ADD_TEXT(struct ceph_msg_connect_reply, msg, tag, "%d");\r
+ PROTO_ADD_TEXT(struct ceph_msg_connect_reply, msg, global_seq, "%d");\r
+ PROTO_ADD_TEXT(struct ceph_msg_connect_reply, msg, connect_seq, "%d");\r
+ PROTO_ADD_TEXT(struct ceph_msg_connect_reply, msg, protocol_version, "%d");\r
+ PROTO_ADD_TEXT(struct ceph_msg_connect_reply, msg, flags, "%x");\r
+\r
return offset;\r
}\r
\r
\r
return offset + sizeof(struct ceph_mon_statfs_reply);\r
}\r
-\r
+#if 0\r
static guint32 dissect_ceph_client_osd_getmap(tvbuff_t *tvb, proto_tree *tree, guint32 offset)\r
{\r
struct ceph_osd_getmap *req;\r
\r
req = (struct ceph_mds_getmap *)tvb_get_ptr(tvb, offset, sizeof(struct ceph_mds_getmap));\r
\r
- PROTO_ADD_TEXT(struct ceph_mds_getmap, req, have_version, "%lld");\r
+ PROTO_ADD_TEXT(struct ceph_mds_getmap, req, monhdr.have_version, "%lld");\r
dissect_ceph_fsid(tvb, tree, offset + offsetof(struct ceph_mds_getmap, fsid));\r
\r
return offset + sizeof(struct ceph_mds_getmap);\r
}\r
-\r
+#endif\r
static guint32 dissect_ceph_client_mds_request(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset)\r
{\r
struct ceph_mds_request_head *head;\r
case CEPH_MSG_CLIENT_CAPS:\r
offset = dissect_ceph_client_mds_caps_request(tvb, pinfo, tree, offset);\r
break;\r
- case CEPH_MSG_OSD_GETMAP:\r
- offset = dissect_ceph_client_osd_getmap(tvb, tree, offset);\r
- break;\r
- case CEPH_MSG_MDS_GETMAP:\r
- offset = dissect_ceph_client_mds_getmap(tvb, tree, offset);\r
- break;\r
default:\r
break;\r
}\r
\r
if (tag == CEPH_MSGR_TAG_ACK) {\r
proto_tree_add_item(ceph_header_tree, hf_ceph_hdr_tag, tvb, offset, 1, TRUE);\r
- proto_tree_add_item(ceph_header_tree, hf_ceph_hdr_seq_ack, tvb, offset+1, 4, TRUE);\r
+ proto_tree_add_item(ceph_header_tree, hf_ceph_hdr_seq_ack, tvb, offset+1, 8, TRUE);\r
offset += ACK_MSG_SIZE;\r
}\r
\r
PROTO_ADD_ITEM(ceph_header_tree, struct ceph_msg_header, hf_ceph_hdr_seq, header, seq);\r
PROTO_ADD_ITEM(ceph_header_tree, struct ceph_msg_header, hf_ceph_hdr_type, header, type);\r
PROTO_ADD_ITEM(ceph_header_tree, struct ceph_msg_header, hf_ceph_hdr_priority, header, priority);\r
- PROTO_ADD_ITEM(ceph_header_tree, struct ceph_msg_header, hf_ceph_hdr_mon_protocol, header, mon_protocol);\r
- PROTO_ADD_ITEM(ceph_header_tree, struct ceph_msg_header, hf_ceph_hdr_osd_protocol, header, osd_protocol);\r
- PROTO_ADD_ITEM(ceph_header_tree, struct ceph_msg_header, hf_ceph_hdr_mds_protocol, header, mds_protocol);\r
+ PROTO_ADD_ITEM(ceph_header_tree, struct ceph_msg_header, hf_ceph_hdr_version, header, version);\r
PROTO_ADD_ITEM(ceph_header_tree, struct ceph_msg_header, hf_ceph_hdr_front_len, header, front_len);\r
PROTO_ADD_ITEM(ceph_header_tree, struct ceph_msg_header, hf_ceph_hdr_middle_len, header, middle_len);\r
PROTO_ADD_ITEM(ceph_header_tree, struct ceph_msg_header, hf_ceph_hdr_data_off, header, data_off);\r
PROTO_ADD_ITEM(ceph_header_tree, struct ceph_msg_header, hf_ceph_hdr_data_len, header, data_len);\r
dissect_ceph_entity_inst(tvb, ceph_header_tree, offset + offsetof(struct ceph_msg_header, src));\r
dissect_ceph_entity_inst(tvb, ceph_header_tree, offset + offsetof(struct ceph_msg_header, orig_src));\r
- dissect_ceph_entity_inst(tvb, ceph_header_tree, offset + offsetof(struct ceph_msg_header, dst));\r
PROTO_ADD_ITEM(ceph_header_tree, struct ceph_msg_header, hf_ceph_hdr_crc, header, crc);\r
\r
offset += sizeof(struct ceph_msg_header);\r
if (tree) {\r
proto_tree_add_item(tree, proto_ceph, tvb, 0, 5, TRUE);\r
proto_tree_add_item(tree, hf_ceph_hdr_tag, tvb, offset, 1, TRUE);\r
- proto_tree_add_item(tree, hf_ceph_hdr_seq_ack, tvb, offset+1, 4, TRUE);\r
- offset += 5;\r
+ proto_tree_add_item(tree, hf_ceph_hdr_seq_ack, tvb, offset+1, 8, TRUE);\r
+ offset += 9;\r
}\r
\r
return offset;\r
-/* Do not modify this file. */
-/* It is created automatically by the Makefile. */
+/*
+ * Do not modify this file.
+ *
+ * It is created automatically by Makefile or Makefile.nmake.
+ */
#ifdef HAVE_CONFIG_H
# include "config.h"
-// -*- mode:C; tab-width:8; c-basic-offset:8; indent-tabs-mode:t -*-
-// vim: ts=8 sw=8 smarttab
-
#ifndef __RADOS_H
#define __RADOS_H
/*
- * Data types for RADOS, the distributed object storage layer used by
- * the Ceph file system.
+ * Data types for the Ceph distributed object storage layer RADOS
+ * (Reliable Autonomic Distributed Object Store).
*/
#include "msgr.h"
/*
* fs id
*/
-typedef struct { unsigned char fsid[16]; } ceph_fsid_t;
+struct ceph_fsid {
+ unsigned char fsid[16];
+};
-static inline int ceph_fsid_compare(const ceph_fsid_t *a,
- const ceph_fsid_t *b)
+static inline int ceph_fsid_compare(const struct ceph_fsid *a,
+ const struct ceph_fsid *b)
{
return memcmp(a, b, sizeof(*a));
}
* ino, object, etc.
*/
typedef __le64 ceph_snapid_t;
-#define CEPH_MAXSNAP ((__u64)(-3))
-#define CEPH_SNAPDIR ((__u64)(-1))
-#define CEPH_NOSNAP ((__u64)(-2))
+#define CEPH_SNAPDIR ((__u64)(-1)) /* reserved for hidden .snap dir */
+#define CEPH_NOSNAP ((__u64)(-2)) /* "head", "live" revision */
+#define CEPH_MAXSNAP ((__u64)(-3)) /* largest valid snapid */
struct ceph_timespec {
__le32 tv_sec;
* placement group.
* we encode this into one __le64.
*/
-#define CEPH_PG_TYPE_REP 1
-#define CEPH_PG_TYPE_RAID4 2
union ceph_pg {
__u64 pg64;
struct {
__s16 preferred; /* preferred primary osd */
__u16 ps; /* placement seed */
- __u32 pool; /* implies crush ruleset */
- } pg;
+ __u32 pool; /* object pool */
+ } __attribute__ ((packed)) pg;
} __attribute__ ((packed));
-#define ceph_pg_is_rep(pg) ((pg).pg.type == CEPH_PG_TYPE_REP)
-#define ceph_pg_is_raid4(pg) ((pg).pg.type == CEPH_PG_TYPE_RAID4)
-
/*
* pg_pool is a set of pgs storing a pool of objects
*
*
* lpgp_num -- as above.
*/
+#define CEPH_PG_TYPE_REP 1
+#define CEPH_PG_TYPE_RAID4 2
struct ceph_pg_pool {
- __u8 type;
- __u8 size;
- __u8 crush_ruleset;
- __le32 pg_num, pgp_num;
- __le32 lpg_num, lpgp_num;
- __le32 last_change; /* most recent epoch changed */
- __le64 snap_seq;
- __le32 snap_epoch;
+ __u8 type; /* CEPH_PG_TYPE_* */
+ __u8 size; /* number of osds in each pg */
+ __u8 crush_ruleset; /* crush placement rule */
+ __le32 pg_num, pgp_num; /* number of pg's */
+ __le32 lpg_num, lpgp_num; /* number of localized pg's */
+ __le32 last_change; /* most recent epoch changed */
+ __le64 snap_seq; /* seq for per-pool snapshot */
+ __le32 snap_epoch; /* epoch of last snap */
__le32 num_snaps;
__le32 num_removed_snap_intervals;
} __attribute__ ((packed));
*/
struct ceph_object_layout {
__le64 ol_pgid; /* raw pg, with _full_ ps precision. */
- __le32 ol_stripe_unit;
+ __le32 ol_stripe_unit; /* for per-object parity, if any */
} __attribute__ ((packed));
/*
CEPH_OSD_OP_SETTRUNC = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 8,
CEPH_OSD_OP_TRIMTRUNC = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 9,
- CEPH_OSD_OP_TMAPUP = CEPH_OSD_OP_MODE_RMW | CEPH_OSD_OP_TYPE_DATA | 10,
- CEPH_OSD_OP_TMAPPUT = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 11,
- CEPH_OSD_OP_TMAPGET = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_DATA | 12,
+ CEPH_OSD_OP_TMAPUP = CEPH_OSD_OP_MODE_RMW | CEPH_OSD_OP_TYPE_DATA | 10,
+ CEPH_OSD_OP_TMAPPUT = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 11,
+ CEPH_OSD_OP_TMAPGET = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_DATA | 12,
- CEPH_OSD_OP_CREATE = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 13,
+ CEPH_OSD_OP_CREATE = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 13,
/** attrs **/
/* read */
#define CEPH_OSD_TMAP_SET 's'
#define CEPH_OSD_TMAP_RM 'r'
-static inline const char *ceph_osd_op_name(int op)
-{
- switch (op) {
- case CEPH_OSD_OP_READ: return "read";
- case CEPH_OSD_OP_STAT: return "stat";
-
- case CEPH_OSD_OP_MASKTRUNC: return "masktrunc";
-
- case CEPH_OSD_OP_WRITE: return "write";
- case CEPH_OSD_OP_DELETE: return "delete";
- case CEPH_OSD_OP_TRUNCATE: return "truncate";
- case CEPH_OSD_OP_ZERO: return "zero";
- case CEPH_OSD_OP_WRITEFULL: return "writefull";
-
- case CEPH_OSD_OP_APPEND: return "append";
- case CEPH_OSD_OP_STARTSYNC: return "startsync";
- case CEPH_OSD_OP_SETTRUNC: return "settrunc";
- case CEPH_OSD_OP_TRIMTRUNC: return "trimtrunc";
-
- case CEPH_OSD_OP_TMAPUP: return "tmapup";
- case CEPH_OSD_OP_TMAPGET: return "tmapget";
- case CEPH_OSD_OP_TMAPPUT: return "tmapput";
-
- case CEPH_OSD_OP_GETXATTR: return "getxattr";
- case CEPH_OSD_OP_GETXATTRS: return "getxattrs";
- case CEPH_OSD_OP_SETXATTR: return "setxattr";
- case CEPH_OSD_OP_SETXATTRS: return "setxattrs";
- case CEPH_OSD_OP_RESETXATTRS: return "resetxattrs";
- case CEPH_OSD_OP_RMXATTR: return "rmxattr";
-
- case CEPH_OSD_OP_PULL: return "pull";
- case CEPH_OSD_OP_PUSH: return "push";
- case CEPH_OSD_OP_BALANCEREADS: return "balance-reads";
- case CEPH_OSD_OP_UNBALANCEREADS: return "unbalance-reads";
- case CEPH_OSD_OP_SCRUB: return "scrub";
-
- case CEPH_OSD_OP_WRLOCK: return "wrlock";
- case CEPH_OSD_OP_WRUNLOCK: return "wrunlock";
- case CEPH_OSD_OP_RDLOCK: return "rdlock";
- case CEPH_OSD_OP_RDUNLOCK: return "rdunlock";
- case CEPH_OSD_OP_UPLOCK: return "uplock";
- case CEPH_OSD_OP_DNLOCK: return "dnlock";
-
- case CEPH_OSD_OP_CALL: return "call";
-
- case CEPH_OSD_OP_PGLS: return "pgls";
-
- default: return "???";
- }
-}
+extern const char *ceph_osd_op_name(int op);
/*
};
enum {
- CEPH_OSD_OP_FLAG_EXCL = 1,
+ CEPH_OSD_OP_FLAG_EXCL = 1, /* EXCL object create */
};
#define EOLDSNAPC ERESTART /* ORDERSNAP flag set; writer has old snapc*/
* payload
*/
struct ceph_osd_op {
- __le16 op;
+ __le16 op; /* CEPH_OSD_OP_* */
+ __le32 flags; /* CEPH_OSD_FLAG_* */
union {
struct {
__le64 offset, length;
- } __attribute__ ((packed));
+ } __attribute__ ((packed)) extent;
struct {
__le32 name_len;
__le32 value_len;
- } __attribute__ ((packed));
+ } __attribute__ ((packed)) xattr;
struct {
__le64 truncate_size;
__le32 truncate_seq;
- } __attribute__ ((packed));
+ } __attribute__ ((packed)) trunc;
struct {
__u8 class_len;
__u8 method_len;
__u8 argc;
__le32 indata_len;
- } __attribute__ ((packed));
+ } __attribute__ ((packed)) cls;
struct {
- __le64 pgls_cookie, count;
- } __attribute__ ((packed));
- struct {
- __le32 flags;
- } __attribute__ ((packed));
+ __le64 cookie, count;
+ } __attribute__ ((packed)) pgls;
};
__le32 payload_len;
} __attribute__ ((packed));
* ceph_osd_op object operations.
*/
struct ceph_osd_request_head {
- __le64 tid;
- __le32 client_inc;
- struct ceph_object_layout layout;
- __le32 osdmap_epoch;
+ __le64 tid; /* transaction id */
+ __le32 client_inc; /* client incarnation */
+ struct ceph_object_layout layout; /* pgid */
+ __le32 osdmap_epoch; /* client's osdmap epoch */
__le32 flags;
- struct ceph_timespec mtime;
+ struct ceph_timespec mtime; /* for mutations only */
struct ceph_eversion reassert_version; /* if we are replaying op */
- __le32 object_len;
- __le32 ticket_len;
+ __le32 object_len; /* length of object name */
- __le64 snapid;
+ __le64 snapid; /* snapid to read */
__le64 snap_seq; /* writer's snap context */
__le32 num_snaps;
} __attribute__ ((packed));
struct ceph_osd_reply_head {
- __le64 tid;
- __le32 client_inc;
+ __le64 tid; /* transaction id */
+ __le32 client_inc; /* client incarnation */
__le32 flags;
struct ceph_object_layout layout;
__le32 osdmap_epoch;
- struct ceph_eversion reassert_version;
+ struct ceph_eversion reassert_version; /* for replaying uncommitted */
- __le32 result;
+ __le32 result; /* result code */
- __le32 object_len;
+ __le32 object_len; /* length of object name */
__le32 num_ops;
struct ceph_osd_op ops[0]; /* ops[], object */
} __attribute__ ((packed));
--- /dev/null
+#ifndef _WS_CEPH_TYPES_H
+#define _WS_CEPH_TYPES_H
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <glib.h>
+
+// this is needed for ceph_fs to compile in userland
+#ifdef _MSC_VER
+typedef char __s8;
+typedef short __s16;
+typedef int __s32;
+typedef __int64 __s64;
+typedef unsigned char __u8;
+typedef unsigned short __u16;
+typedef unsigned int __u32;
+typedef unsigned __int64 __u64;
+typedef __u16 __le16;
+typedef __u32 __le32;
+typedef __u64 __le64;
+#define __attribute__(x)
+#define O_ACCMODE (O_RDONLY | O_RDWR | O_WRONLY)
+#include <winsock.h>
+#else
+#include <netinet/in.h>
+#include <linux/types.h>
+#endif
+typedef int bool;
+
+#define le16_to_cpu(x) (x)
+#define le32_to_cpu(x) (x)
+#define le64_to_cpu(x) (x)
+
+
+typedef guint32 uint32_t;
+
+#include <fcntl.h>
+#include <string.h>
+
+#ifdef _MSC_VER
+#pragma pack(1)
+#endif
+#include "ceph_fs.h"
+#ifdef _MSC_VER
+#pragma pack()
+#endif
+
+
+
+#endif
projects / ceph.git / commitdiff