[mirror_ubuntu-bionic-kernel.git] / fs / ceph / ceph_fs.h

/*
 * ceph_fs.h - Ceph constants and data types to share between kernel and
 * user space.
 *
 * Most types in this file are defined as little-endian, and are
 * primarily intended to describe data structures that pass over the
 * wire or that are stored on disk.
 *
 * LGPL2
 */

#ifndef _FS_CEPH_CEPH_FS_H
#define _FS_CEPH_CEPH_FS_H

#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
 * internal cluster protocols separately from the public,
 * client-facing protocol.
 */
#define CEPH_OSD_PROTOCOL     7 /* cluster internal */
#define CEPH_MDS_PROTOCOL     9 /* cluster internal */
#define CEPH_MON_PROTOCOL     5 /* cluster internal */
#define CEPH_OSDC_PROTOCOL   20 /* server/client */
#define CEPH_MDSC_PROTOCOL   29 /* server/client */
#define CEPH_MONC_PROTOCOL   15 /* server/client */


#define CEPH_INO_ROOT  1

/* arbitrary limit on max # of monitors (cluster of 3 is typical) */
#define CEPH_MAX_MON   31


unsigned int ceph_full_name_hash(const char *name, unsigned int len);


/*
 * ceph_file_layout - describe data layout for a file/inode
 */
struct ceph_file_layout {
	/* file -> object mapping */
	__le32 fl_stripe_unit;     /* stripe unit, in bytes.  must be multiple
				      of page size. */
	__le32 fl_stripe_count;    /* over this many objects */
	__le32 fl_object_size;     /* until objects are this big, then move to
				      new objects */
	__le32 fl_cas_hash;        /* 0 = none; 1 = sha256 */

	/* pg -> disk layout */
	__le32 fl_object_stripe_unit;  /* for per-object parity, if any */

	/* object -> pg layout */
	__le32 fl_pg_preferred; /* preferred primary for pg (-1 for none) */
	__le32 fl_pg_pool;      /* namespace, crush ruleset, rep level */
} __attribute__ ((packed));


/*********************************************
 * message layer
 */

/*
 * message types
 */

/* misc */
#define CEPH_MSG_SHUTDOWN               1
#define CEPH_MSG_PING                   2

/* client <-> monitor */
#define CEPH_MSG_MON_MAP                4
#define CEPH_MSG_MON_GET_MAP            5
#define CEPH_MSG_CLIENT_MOUNT           10
#define CEPH_MSG_CLIENT_MOUNT_ACK       11
#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_RECONNECT       23

#define CEPH_MSG_CLIENT_REQUEST         24
#define CEPH_MSG_CLIENT_REQUEST_FORWARD 25
#define CEPH_MSG_CLIENT_REPLY           26
#define CEPH_MSG_CLIENT_CAPS            0x310
#define CEPH_MSG_CLIENT_LEASE           0x311
#define CEPH_MSG_CLIENT_SNAP            0x312
#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 {
	struct ceph_mon_request_header monhdr;
	struct ceph_fsid fsid;
	__le64 tid;
} __attribute__ ((packed));

struct ceph_statfs {
	__le64 kb, kb_used, kb_avail;
	__le64 num_objects;
} __attribute__ ((packed));

struct ceph_mon_statfs_reply {
	struct ceph_fsid fsid;
	__le64 tid;
	__le64 version;
	struct ceph_statfs st;
} __attribute__ ((packed));

struct ceph_osd_getmap {
	struct ceph_mon_request_header monhdr;
	struct ceph_fsid fsid;
	__le32 start;
} __attribute__ ((packed));

struct ceph_mds_getmap {
	struct ceph_mon_request_header monhdr;
	struct ceph_fsid fsid;
} __attribute__ ((packed));

struct ceph_client_mount {
	struct ceph_mon_request_header monhdr;
} __attribute__ ((packed));

struct ceph_mon_subscribe_item {
	__le64 have_version;	__le64 have;
	__u8 onetime;
} __attribute__ ((packed));

/*
 * mds states
 *   > 0 -> in
 *  <= 0 -> out
 */
#define CEPH_MDS_STATE_DNE          0  /* down, does not exist. */
#define CEPH_MDS_STATE_STOPPED     -1  /* down, once existed, but no subtrees.
					  empty log. */
#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_STANDBY_REPLAY -8 /* up, tailing active node's journal */

#define CEPH_MDS_STATE_REPLAY       8  /* up, replaying journal. */
#define CEPH_MDS_STATE_RESOLVE      9  /* up, disambiguating distributed
					  operations (import, rename, etc.) */
#define CEPH_MDS_STATE_RECONNECT    10 /* up, reconnect to clients */
#define CEPH_MDS_STATE_REJOIN       11 /* up, rejoining distributed cache */
#define CEPH_MDS_STATE_CLIENTREPLAY 12 /* up, replaying client operations */
#define CEPH_MDS_STATE_ACTIVE       13 /* up, active */
#define CEPH_MDS_STATE_STOPPING     14 /* up, but exporting metadata */

extern const char *ceph_mds_state_name(int s);


/*
 * metadata lock types.
 *  - these are bitmasks.. we can compose them
 *  - they also define the lock ordering by the MDS
 *  - a few of these are internal to the mds
 */
#define CEPH_LOCK_DN          1
#define CEPH_LOCK_ISNAP       2
#define CEPH_LOCK_IVERSION    4     /* mds internal */
#define CEPH_LOCK_IFILE       8     /* mds internal */
#define CEPH_LOCK_IAUTH       32
#define CEPH_LOCK_ILINK       64
#define CEPH_LOCK_IDFT        128   /* dir frag tree */
#define CEPH_LOCK_INEST       256   /* mds internal */
#define CEPH_LOCK_IXATTR      512
#define CEPH_LOCK_INO         2048  /* immutable inode bits; not a lock */

/* client_session ops */
enum {
	CEPH_SESSION_REQUEST_OPEN,
	CEPH_SESSION_OPEN,
	CEPH_SESSION_REQUEST_CLOSE,
	CEPH_SESSION_CLOSE,
	CEPH_SESSION_REQUEST_RENEWCAPS,
	CEPH_SESSION_RENEWCAPS,
	CEPH_SESSION_STALE,
	CEPH_SESSION_RECALL_STATE,
};

extern const char *ceph_session_op_name(int op);

struct ceph_mds_session_head {
	__le32 op;
	__le64 seq;
	struct ceph_timespec stamp;
	__le32 max_caps, max_leases;
} __attribute__ ((packed));

/* client_request */
/*
 * metadata ops.
 *  & 0x001000 -> write op
 *  & 0x010000 -> follow symlink (e.g. stat(), not lstat()).
 &  & 0x100000 -> use weird ino/path trace
 */
#define CEPH_MDS_OP_WRITE        0x001000
enum {
	CEPH_MDS_OP_LOOKUP     = 0x00100,
	CEPH_MDS_OP_GETATTR    = 0x00101,
	CEPH_MDS_OP_LOOKUPHASH = 0x00102,
	CEPH_MDS_OP_LOOKUPPARENT = 0x00103,

	CEPH_MDS_OP_SETXATTR   = 0x01105,
	CEPH_MDS_OP_RMXATTR    = 0x01106,
	CEPH_MDS_OP_SETLAYOUT  = 0x01107,
	CEPH_MDS_OP_SETATTR    = 0x01108,

	CEPH_MDS_OP_MKNOD      = 0x01201,
	CEPH_MDS_OP_LINK       = 0x01202,
	CEPH_MDS_OP_UNLINK     = 0x01203,
	CEPH_MDS_OP_RENAME     = 0x01204,
	CEPH_MDS_OP_MKDIR      = 0x01220,
	CEPH_MDS_OP_RMDIR      = 0x01221,
	CEPH_MDS_OP_SYMLINK    = 0x01222,

	CEPH_MDS_OP_CREATE     = 0x00301,
	CEPH_MDS_OP_OPEN       = 0x00302,
	CEPH_MDS_OP_READDIR    = 0x00305,

	CEPH_MDS_OP_LOOKUPSNAP = 0x00400,
	CEPH_MDS_OP_MKSNAP     = 0x01400,
	CEPH_MDS_OP_RMSNAP     = 0x01401,
	CEPH_MDS_OP_LSSNAP     = 0x00402,
};

extern const char *ceph_mds_op_name(int op);


#define CEPH_SETATTR_MODE   1
#define CEPH_SETATTR_UID    2
#define CEPH_SETATTR_GID    4
#define CEPH_SETATTR_MTIME  8
#define CEPH_SETATTR_ATIME 16
#define CEPH_SETATTR_SIZE  32
#define CEPH_SETATTR_CTIME 64

union ceph_mds_request_args {
	struct {
		__le32 mask;                 /* CEPH_CAP_* */
	} __attribute__ ((packed)) getattr;
	struct {
		__le32 mode;
		__le32 uid;
		__le32 gid;
		struct ceph_timespec mtime;
		struct ceph_timespec atime;
		__le64 size, old_size;       /* old_size needed by truncate */
		__le32 mask;                 /* CEPH_SETATTR_* */
	} __attribute__ ((packed)) setattr;
	struct {
		__le32 frag;                 /* which dir fragment */
		__le32 max_entries;          /* how many dentries to grab */
	} __attribute__ ((packed)) readdir;
	struct {
		__le32 mode;
		__le32 rdev;
	} __attribute__ ((packed)) mknod;
	struct {
		__le32 mode;
	} __attribute__ ((packed)) mkdir;
	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;
	} __attribute__ ((packed)) setxattr;
	struct {
		struct ceph_file_layout layout;
	} __attribute__ ((packed)) setlayout;
} __attribute__ ((packed));

#define CEPH_MDS_FLAG_REPLAY        1  /* this is a replayed op */
#define CEPH_MDS_FLAG_WANT_DENTRY   2  /* want dentry in reply */

struct ceph_mds_request_head {
	__le64 tid, oldest_client_tid;
	__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. (if replaying) */
	union ceph_mds_request_args args;
} __attribute__ ((packed));

/* cap/lease release record */
struct ceph_mds_request_release {
	__le64 ino, cap_id;            /* ino and unique cap id */
	__le32 caps, wanted;           /* new issued, wanted */
	__le32 seq, issue_seq, mseq;
	__le32 dname_seq;              /* if releasing a dentry lease, a */
	__le32 dname_len;              /* string follows. */
} __attribute__ ((packed));

/* client reply */
struct ceph_mds_reply_head {
	__le64 tid;
	__le32 op;
	__le32 result;
	__le32 mdsmap_epoch;
	__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 */
} __attribute__ ((packed));

struct ceph_frag_tree_head {
	__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;           /* caps issued, wanted */
	__le64 cap_id;
	__le32 seq, mseq;
	__le64 realm;                  /* snap realm */
	__u8 flags;                    /* CEPH_CAP_FLAG_* */
} __attribute__ ((packed));

#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;                /* 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;
	__le64 size, max_size, truncate_size;
	__le32 truncate_seq;
	__le32 mode, uid, gid;
	__le32 nlink;
	__le64 files, subdirs, rbytes, rfiles, rsubdirs;  /* dir stats */
	struct ceph_timespec rctime;
	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;            /* 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 dist[];
} __attribute__ ((packed));

/* file access modes */
#define CEPH_FILE_MODE_PIN        0
#define CEPH_FILE_MODE_RD         1
#define CEPH_FILE_MODE_WR         2
#define CEPH_FILE_MODE_RDWR       3  /* RD | WR */
#define CEPH_FILE_MODE_LAZY       4  /* lazy io */
#define CEPH_FILE_MODE_NUM        8  /* bc these are bit fields.. mostly */

int ceph_flags_to_mode(int flags);


/* capability bits */
#define CEPH_CAP_PIN         1  /* no specific capabilities beyond the pin */

/* generic cap bits */
#define CEPH_CAP_GSHARED     1  /* client can reads */
#define CEPH_CAP_GEXCL       2  /* client can read and update */
#define CEPH_CAP_GCACHE      4  /* (file) client can cache reads */
#define CEPH_CAP_GRD         8  /* (file) client can read */
#define CEPH_CAP_GWR        16  /* (file) client can write */
#define CEPH_CAP_GBUFFER    32  /* (file) client can buffer writes */
#define CEPH_CAP_GWREXTEND  64  /* (file) client can extend EOF */
#define CEPH_CAP_GLAZYIO   128  /* (file) client can perform lazy io */

/* per-lock shift */
#define CEPH_CAP_SAUTH      2
#define CEPH_CAP_SLINK      4
#define CEPH_CAP_SXATTR     6
#define CEPH_CAP_SFILE      8   /* goes at the end (uses >2 cap bits) */

#define CEPH_CAP_BITS       16

/* composed values */
#define CEPH_CAP_AUTH_SHARED  (CEPH_CAP_GSHARED  << CEPH_CAP_SAUTH)
#define CEPH_CAP_AUTH_EXCL     (CEPH_CAP_GEXCL     << CEPH_CAP_SAUTH)
#define CEPH_CAP_LINK_SHARED  (CEPH_CAP_GSHARED  << CEPH_CAP_SLINK)
#define CEPH_CAP_LINK_EXCL     (CEPH_CAP_GEXCL     << CEPH_CAP_SLINK)
#define CEPH_CAP_XATTR_SHARED (CEPH_CAP_GSHARED  << CEPH_CAP_SXATTR)
#define CEPH_CAP_XATTR_EXCL    (CEPH_CAP_GEXCL     << CEPH_CAP_SXATTR)
#define CEPH_CAP_FILE(x)    (x << CEPH_CAP_SFILE)
#define CEPH_CAP_FILE_SHARED   (CEPH_CAP_GSHARED   << CEPH_CAP_SFILE)
#define CEPH_CAP_FILE_EXCL     (CEPH_CAP_GEXCL     << CEPH_CAP_SFILE)
#define CEPH_CAP_FILE_CACHE    (CEPH_CAP_GCACHE    << CEPH_CAP_SFILE)
#define CEPH_CAP_FILE_RD       (CEPH_CAP_GRD       << CEPH_CAP_SFILE)
#define CEPH_CAP_FILE_WR       (CEPH_CAP_GWR       << CEPH_CAP_SFILE)
#define CEPH_CAP_FILE_BUFFER   (CEPH_CAP_GBUFFER   << CEPH_CAP_SFILE)
#define CEPH_CAP_FILE_WREXTEND (CEPH_CAP_GWREXTEND << CEPH_CAP_SFILE)
#define CEPH_CAP_FILE_LAZYIO   (CEPH_CAP_GLAZYIO   << CEPH_CAP_SFILE)

/* cap masks (for getattr) */
#define CEPH_STAT_CAP_INODE    CEPH_CAP_PIN
#define CEPH_STAT_CAP_TYPE     CEPH_CAP_PIN  /* mode >> 12 */
#define CEPH_STAT_CAP_SYMLINK  CEPH_CAP_PIN
#define CEPH_STAT_CAP_UID      CEPH_CAP_AUTH_SHARED
#define CEPH_STAT_CAP_GID      CEPH_CAP_AUTH_SHARED
#define CEPH_STAT_CAP_MODE     CEPH_CAP_AUTH_SHARED
#define CEPH_STAT_CAP_NLINK    CEPH_CAP_LINK_SHARED
#define CEPH_STAT_CAP_LAYOUT   CEPH_CAP_FILE_SHARED
#define CEPH_STAT_CAP_MTIME    CEPH_CAP_FILE_SHARED
#define CEPH_STAT_CAP_SIZE     CEPH_CAP_FILE_SHARED
#define CEPH_STAT_CAP_ATIME    CEPH_CAP_FILE_SHARED  /* fixme */
#define CEPH_STAT_CAP_XATTR    CEPH_CAP_XATTR_SHARED
#define CEPH_STAT_CAP_INODE_ALL (CEPH_CAP_PIN |			\
				 CEPH_CAP_AUTH_SHARED |	\
				 CEPH_CAP_LINK_SHARED |	\
				 CEPH_CAP_FILE_SHARED |	\
				 CEPH_CAP_XATTR_SHARED)

#define CEPH_CAP_ANY_SHARED (CEPH_CAP_AUTH_SHARED |			\
			      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 |	\
			   CEPH_CAP_FILE_CACHE)

#define CEPH_CAP_ANY_EXCL (CEPH_CAP_AUTH_EXCL |		\
			   CEPH_CAP_LINK_EXCL |		\
			   CEPH_CAP_XATTR_EXCL |	\
			   CEPH_CAP_FILE_EXCL)
#define CEPH_CAP_ANY_FILE_WR (CEPH_CAP_FILE_WR | CEPH_CAP_FILE_BUFFER |	\
			      CEPH_CAP_FILE_EXCL)
#define CEPH_CAP_ANY_WR   (CEPH_CAP_ANY_EXCL | CEPH_CAP_ANY_FILE_WR)
#define CEPH_CAP_ANY      (CEPH_CAP_ANY_RD | CEPH_CAP_ANY_EXCL | \
			   CEPH_CAP_ANY_FILE_WR | CEPH_CAP_PIN)

#define CEPH_CAP_LOCKS (CEPH_LOCK_IFILE | CEPH_LOCK_IAUTH | CEPH_LOCK_ILINK | \
			CEPH_LOCK_IXATTR)

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 */
	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 */
};

extern const char *ceph_cap_op_name(int op);

/*
 * caps message, used for capability callbacks, acks, requests, etc.
 */
struct ceph_mds_caps {
	__le32 op;                  /* CEPH_CAP_OP_* */
	__le64 ino, realm;
	__le64 cap_id;
	__le32 seq, issue_seq;
	__le32 caps, wanted, dirty; /* latest issued/wanted/dirty */
	__le32 migrate_seq;
	__le64 snap_follows;
	__le32 snap_trace_len;
	__le64 client_tid;          /* for FLUSH(SNAP) -> FLUSH(SNAP)_ACK */

	/* authlock */
	__le32 uid, gid, mode;

	/* linklock */
	__le32 nlink;

	/* xattrlock */
	__le32 xattr_len;
	__le64 xattr_version;

	/* filelock */
	__le64 size, max_size, truncate_size;
	__le32 truncate_seq;
	struct ceph_timespec mtime, atime, ctime;
	struct ceph_file_layout layout;
	__le32 time_warp_seq;
} __attribute__ ((packed));

/* cap release msg head */
struct ceph_mds_cap_release {
	__le32 num;                /* number of cap_items that follow */
} __attribute__ ((packed));

struct ceph_mds_cap_item {
	__le64 ino;
	__le64 cap_id;
	__le32 migrate_seq, seq;
} __attribute__ ((packed));

#define CEPH_MDS_LEASE_REVOKE           1  /*    mds  -> client */
#define CEPH_MDS_LEASE_RELEASE          2  /* client  -> mds    */
#define CEPH_MDS_LEASE_RENEW            3  /* client <-> mds    */
#define CEPH_MDS_LEASE_REVOKE_ACK       4  /* client  -> mds    */

extern const char *ceph_lease_op_name(int o);

/* lease msg header */
struct ceph_mds_lease {
	__u8 action;            /* CEPH_MDS_LEASE_* */
	__le16 mask;            /* which lease */
	__le64 ino;
	__le64 first, last;     /* snap range */
	__le32 seq;
	__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;
	__le32 wanted;
	__le32 issued;
	__le64 size;
	struct ceph_timespec mtime, atime;
	__le64 snaprealm;
	__le64 pathbase;        /* base ino for our path to this ino */
} __attribute__ ((packed));
/* followed by encoded string */

struct ceph_mds_snaprealm_reconnect {
	__le64 ino;     /* snap realm base */
	__le64 seq;     /* snap seq for this snap realm */
	__le64 parent;  /* parent realm */
} __attribute__ ((packed));

/*
 * snaps
 */
enum {
	CEPH_SNAP_OP_UPDATE,  /* CREATE or DESTROY */
	CEPH_SNAP_OP_CREATE,
	CEPH_SNAP_OP_DESTROY,
	CEPH_SNAP_OP_SPLIT,
};

extern const char *ceph_snap_op_name(int o);

/* snap msg header */
struct ceph_mds_snap_head {
	__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 */

/*
 * encode info about a snaprealm, as viewed by a client
 */
struct ceph_mds_snap_realm {
	__le64 ino;           /* ino */
	__le64 created;       /* snap: when created */
	__le64 parent;        /* ino: parent realm */
	__le64 parent_since;  /* snap: same parent since */
	__le64 seq;           /* snap: version */
	__le32 num_snaps;
	__le32 num_prior_parent_snaps;
} __attribute__ ((packed));
/* followed by my snap list, then prior parent snap list */

#endif
Commit	Line	Data
0dee3c28 SW	1	/*
	2	* ceph_fs.h - Ceph constants and data types to share between kernel and
	3	* user space.
	4	*
	5	* Most types in this file are defined as little-endian, and are
	6	* primarily intended to describe data structures that pass over the
	7	* wire or that are stored on disk.
	8	*
	9	* LGPL2
	10	*/
	11
	12	#ifndef _FS_CEPH_CEPH_FS_H
	13	#define _FS_CEPH_CEPH_FS_H
	14
	15	#include "msgr.h"
	16	#include "rados.h"
	17
	18	/*
	19	* Ceph release version
	20	*/
	21	#define CEPH_VERSION_MAJOR 0
	22	#define CEPH_VERSION_MINOR 16
	23	#define CEPH_VERSION_PATCH 1
	24
	25	#define _CEPH_STRINGIFY(x) #x
	26	#define CEPH_STRINGIFY(x) _CEPH_STRINGIFY(x)
	27	#define CEPH_MAKE_VERSION(x, y, z) CEPH_STRINGIFY(x) "." CEPH_STRINGIFY(y) \
	28	"." CEPH_STRINGIFY(z)
	29	#define CEPH_VERSION CEPH_MAKE_VERSION(CEPH_VERSION_MAJOR, \
	30	CEPH_VERSION_MINOR, CEPH_VERSION_PATCH)
	31
	32	/*
	33	* subprotocol versions. when specific messages types or high-level
	34	* protocols change, bump the affected components. we keep rev
	35	* internal cluster protocols separately from the public,
	36	* client-facing protocol.
	37	*/
	38	#define CEPH_OSD_PROTOCOL 7 /* cluster internal */
	39	#define CEPH_MDS_PROTOCOL 9 /* cluster internal */
13e38c8a	40	#define CEPH_MON_PROTOCOL 5 /* cluster internal */
0dee3c28 SW	41	#define CEPH_OSDC_PROTOCOL 20 /* server/client */
0dee3c28 SW	42	#define CEPH_MDSC_PROTOCOL 29 /* server/client */
13e38c8a	43	#define CEPH_MONC_PROTOCOL 15 /* server/client */
0dee3c28 SW	44
	45
	46	#define CEPH_INO_ROOT 1
	47
	48	/* arbitrary limit on max # of monitors (cluster of 3 is typical) */
	49	#define CEPH_MAX_MON 31
	50
	51
	52	unsigned int ceph_full_name_hash(const char *name, unsigned int len);
	53
	54
	55	/*
	56	* ceph_file_layout - describe data layout for a file/inode
	57	*/
	58	struct ceph_file_layout {
	59	/* file -> object mapping */
	60	__le32 fl_stripe_unit; /* stripe unit, in bytes. must be multiple
	61	of page size. */
	62	__le32 fl_stripe_count; /* over this many objects */
	63	__le32 fl_object_size; /* until objects are this big, then move to
	64	new objects */
	65	__le32 fl_cas_hash; /* 0 = none; 1 = sha256 */
	66
	67	/* pg -> disk layout */
	68	__le32 fl_object_stripe_unit; /* for per-object parity, if any */
	69
	70	/* object -> pg layout */
	71	__le32 fl_pg_preferred; /* preferred primary for pg (-1 for none) */
	72	__le32 fl_pg_pool; /* namespace, crush ruleset, rep level */
	73	} __attribute__ ((packed));
	74
	75
	76
	77
	78	/*********************************************
	79	* message layer
	80	*/
	81
	82	/*
	83	* message types
	84	*/
	85
	86	/* misc */
	87	#define CEPH_MSG_SHUTDOWN 1
	88	#define CEPH_MSG_PING 2
	89
	90	/* client <-> monitor */
	91	#define CEPH_MSG_MON_MAP 4
	92	#define CEPH_MSG_MON_GET_MAP 5
	93	#define CEPH_MSG_CLIENT_MOUNT 10
	94	#define CEPH_MSG_CLIENT_MOUNT_ACK 11
	95	#define CEPH_MSG_STATFS 13
	96	#define CEPH_MSG_STATFS_REPLY 14
	97	#define CEPH_MSG_MON_SUBSCRIBE 15
	98	#define CEPH_MSG_MON_SUBSCRIBE_ACK 16
	99
	100	/* client <-> mds */
	101	#define CEPH_MSG_MDS_GETMAP 20
	102	#define CEPH_MSG_MDS_MAP 21
	103
	104	#define CEPH_MSG_CLIENT_SESSION 22
	105	#define CEPH_MSG_CLIENT_RECONNECT 23
	106
	107	#define CEPH_MSG_CLIENT_REQUEST 24
108	#define CEPH_MSG_CLIENT_REQUEST_FORWARD 25
109	#define CEPH_MSG_CLIENT_REPLY 26
110	#define CEPH_MSG_CLIENT_CAPS 0x310
111	#define CEPH_MSG_CLIENT_LEASE 0x311
112	#define CEPH_MSG_CLIENT_SNAP 0x312
113	#define CEPH_MSG_CLIENT_CAPRELEASE 0x313
114
115	/* osd */
116	#define CEPH_MSG_OSD_GETMAP 40
117	#define CEPH_MSG_OSD_MAP 41
118	#define CEPH_MSG_OSD_OP 42
119	#define CEPH_MSG_OSD_OPREPLY 43
120
13e38c8a SW	121	struct ceph_mon_request_header {
	122	__le64 have_version;
	123	__le16 session_mon;
	124	__le64 session_mon_tid;
	125	} __attribute__ ((packed));
0dee3c28 SW	126
0dee3c28 SW	127	struct ceph_mon_statfs {
13e38c8a	128	struct ceph_mon_request_header monhdr;
0dee3c28 SW	129	struct ceph_fsid fsid;
	130	__le64 tid;
	131	} __attribute__ ((packed));
	132
	133	struct ceph_statfs {
	134	__le64 kb, kb_used, kb_avail;
	135	__le64 num_objects;
	136	} __attribute__ ((packed));
	137
	138	struct ceph_mon_statfs_reply {
	139	struct ceph_fsid fsid;
	140	__le64 tid;
	141	__le64 version;
	142	struct ceph_statfs st;
	143	} __attribute__ ((packed));
	144
	145	struct ceph_osd_getmap {
13e38c8a	146	struct ceph_mon_request_header monhdr;
0dee3c28 SW	147	struct ceph_fsid fsid;
	148	__le32 start;
	149	} __attribute__ ((packed));
	150
	151	struct ceph_mds_getmap {
13e38c8a	152	struct ceph_mon_request_header monhdr;
0dee3c28 SW	153	struct ceph_fsid fsid;
	154	} __attribute__ ((packed));
	155
	156	struct ceph_client_mount {
13e38c8a	157	struct ceph_mon_request_header monhdr;
0dee3c28 SW	158	} __attribute__ ((packed));
	159
	160	struct ceph_mon_subscribe_item {
13e38c8a	161	__le64 have_version; __le64 have;
0dee3c28 SW	162	__u8 onetime;
	163	} __attribute__ ((packed));
	164
	165	/*
	166	* mds states
	167	* > 0 -> in
	168	* <= 0 -> out
	169	*/
	170	#define CEPH_MDS_STATE_DNE 0 /* down, does not exist. */
	171	#define CEPH_MDS_STATE_STOPPED -1 /* down, once existed, but no subtrees.
	172	empty log. */
	173	#define CEPH_MDS_STATE_BOOT -4 /* up, boot announcement. */
	174	#define CEPH_MDS_STATE_STANDBY -5 /* up, idle. waiting for assignment. */
	175	#define CEPH_MDS_STATE_CREATING -6 /* up, creating MDS instance. */
	176	#define CEPH_MDS_STATE_STARTING -7 /* up, starting previously stopped mds */
	177	#define CEPH_MDS_STATE_STANDBY_REPLAY -8 /* up, tailing active node's journal */
	178
	179	#define CEPH_MDS_STATE_REPLAY 8 /* up, replaying journal. */
	180	#define CEPH_MDS_STATE_RESOLVE 9 /* up, disambiguating distributed
	181	operations (import, rename, etc.) */
	182	#define CEPH_MDS_STATE_RECONNECT 10 /* up, reconnect to clients */
	183	#define CEPH_MDS_STATE_REJOIN 11 /* up, rejoining distributed cache */
	184	#define CEPH_MDS_STATE_CLIENTREPLAY 12 /* up, replaying client operations */
	185	#define CEPH_MDS_STATE_ACTIVE 13 /* up, active */
	186	#define CEPH_MDS_STATE_STOPPING 14 /* up, but exporting metadata */
	187
	188	extern const char *ceph_mds_state_name(int s);
	189
	190
	191	/*
	192	* metadata lock types.
	193	* - these are bitmasks.. we can compose them
	194	* - they also define the lock ordering by the MDS
	195	* - a few of these are internal to the mds
	196	*/
	197	#define CEPH_LOCK_DN 1
	198	#define CEPH_LOCK_ISNAP 2
	199	#define CEPH_LOCK_IVERSION 4 /* mds internal */
	200	#define CEPH_LOCK_IFILE 8 /* mds internal */
	201	#define CEPH_LOCK_IAUTH 32
	202	#define CEPH_LOCK_ILINK 64
	203	#define CEPH_LOCK_IDFT 128 /* dir frag tree */
	204	#define CEPH_LOCK_INEST 256 /* mds internal */
	205	#define CEPH_LOCK_IXATTR 512
	206	#define CEPH_LOCK_INO 2048 /* immutable inode bits; not a lock */
	207
	208	/* client_session ops */
	209	enum {
	210	CEPH_SESSION_REQUEST_OPEN,
	211	CEPH_SESSION_OPEN,
	212	CEPH_SESSION_REQUEST_CLOSE,
	213	CEPH_SESSION_CLOSE,
	214	CEPH_SESSION_REQUEST_RENEWCAPS,
	215	CEPH_SESSION_RENEWCAPS,
	216	CEPH_SESSION_STALE,
	217	CEPH_SESSION_RECALL_STATE,
	218	};
	219
	220	extern const char *ceph_session_op_name(int op);
	221
	222	struct ceph_mds_session_head {
	223	__le32 op;
	224	__le64 seq;
	225	struct ceph_timespec stamp;
226	__le32 max_caps, max_leases;
227	} __attribute__ ((packed));
228
229	/* client_request */
230	/*
231	* metadata ops.
232	* & 0x001000 -> write op
233	* & 0x010000 -> follow symlink (e.g. stat(), not lstat()).
234	& & 0x100000 -> use weird ino/path trace
235	*/
236	#define CEPH_MDS_OP_WRITE 0x001000
237	enum {
238	CEPH_MDS_OP_LOOKUP = 0x00100,
239	CEPH_MDS_OP_GETATTR = 0x00101,
240	CEPH_MDS_OP_LOOKUPHASH = 0x00102,
241	CEPH_MDS_OP_LOOKUPPARENT = 0x00103,
242
243	CEPH_MDS_OP_SETXATTR = 0x01105,
244	CEPH_MDS_OP_RMXATTR = 0x01106,
245	CEPH_MDS_OP_SETLAYOUT = 0x01107,
246	CEPH_MDS_OP_SETATTR = 0x01108,
247
248	CEPH_MDS_OP_MKNOD = 0x01201,
249	CEPH_MDS_OP_LINK = 0x01202,
250	CEPH_MDS_OP_UNLINK = 0x01203,
251	CEPH_MDS_OP_RENAME = 0x01204,
252	CEPH_MDS_OP_MKDIR = 0x01220,
253	CEPH_MDS_OP_RMDIR = 0x01221,
254	CEPH_MDS_OP_SYMLINK = 0x01222,
255
256	CEPH_MDS_OP_CREATE = 0x00301,
257	CEPH_MDS_OP_OPEN = 0x00302,
258	CEPH_MDS_OP_READDIR = 0x00305,
259
260	CEPH_MDS_OP_LOOKUPSNAP = 0x00400,
261	CEPH_MDS_OP_MKSNAP = 0x01400,
262	CEPH_MDS_OP_RMSNAP = 0x01401,
263	CEPH_MDS_OP_LSSNAP = 0x00402,
264	};
265
266	extern const char *ceph_mds_op_name(int op);
267
268
269	#define CEPH_SETATTR_MODE 1
270	#define CEPH_SETATTR_UID 2
271	#define CEPH_SETATTR_GID 4
272	#define CEPH_SETATTR_MTIME 8
273	#define CEPH_SETATTR_ATIME 16
274	#define CEPH_SETATTR_SIZE 32
275	#define CEPH_SETATTR_CTIME 64
276
277	union ceph_mds_request_args {
278	struct {
279	__le32 mask; /* CEPH_CAP_* */
280	} __attribute__ ((packed)) getattr;
281	struct {
282	__le32 mode;
283	__le32 uid;
284	__le32 gid;
285	struct ceph_timespec mtime;
286	struct ceph_timespec atime;
287	__le64 size, old_size; /* old_size needed by truncate */
288	__le32 mask; /* CEPH_SETATTR_* */
289	} __attribute__ ((packed)) setattr;
290	struct {
291	__le32 frag; /* which dir fragment */
292	__le32 max_entries; /* how many dentries to grab */
293	} __attribute__ ((packed)) readdir;
294	struct {
295	__le32 mode;
296	__le32 rdev;
297	} __attribute__ ((packed)) mknod;
298	struct {
299	__le32 mode;
300	} __attribute__ ((packed)) mkdir;
301	struct {
302	__le32 flags;
303	__le32 mode;
304	__le32 stripe_unit; /* layout for newly created file */
305	__le32 stripe_count; /* ... */
306	__le32 object_size;
307	__le32 file_replication;
308	__le32 preferred;
309	} __attribute__ ((packed)) open;
310	struct {
311	__le32 flags;
312	} __attribute__ ((packed)) setxattr;
313	struct {
314	struct ceph_file_layout layout;
315	} __attribute__ ((packed)) setlayout;
316	} __attribute__ ((packed));
317
318	#define CEPH_MDS_FLAG_REPLAY 1 /* this is a replayed op */
319	#define CEPH_MDS_FLAG_WANT_DENTRY 2 /* want dentry in reply */
320
321	struct ceph_mds_request_head {
322	__le64 tid, oldest_client_tid;
323	__le32 mdsmap_epoch; /* on client */
324	__le32 flags; /* CEPH_MDS_FLAG_* */
325	__u8 num_retry, num_fwd; /* count retry, fwd attempts */
326	__le16 num_releases; /* # include cap/lease release records */
327	__le32 op; /* mds op code */
328	__le32 caller_uid, caller_gid;
329	__le64 ino; /* use this ino for openc, mkdir, mknod,
330	etc. (if replaying) */
331	union ceph_mds_request_args args;
332	} __attribute__ ((packed));
333
334	/* cap/lease release record */
335	struct ceph_mds_request_release {
336	__le64 ino, cap_id; /* ino and unique cap id */
337	__le32 caps, wanted; /* new issued, wanted */
338	__le32 seq, issue_seq, mseq;
339	__le32 dname_seq; /* if releasing a dentry lease, a */
340	__le32 dname_len; /* string follows. */
341	} __attribute__ ((packed));
342
343	/* client reply */
344	struct ceph_mds_reply_head {
345	__le64 tid;
346	__le32 op;
347	__le32 result;
348	__le32 mdsmap_epoch;
349	__u8 safe; /* true if committed to disk */
350	__u8 is_dentry, is_target; /* true if dentry, target inode records
351	are included with reply */
352	} __attribute__ ((packed));
353
354	/* one for each node split */
355	struct ceph_frag_tree_split {
356	__le32 frag; /* this frag splits... */
357	__le32 by; /* ...by this many bits */
358	} __attribute__ ((packed));
359
360	struct ceph_frag_tree_head {
361	__le32 nsplits; /* num ceph_frag_tree_split records */
362	struct ceph_frag_tree_split splits[];
363	} __attribute__ ((packed));
364
365	/* capability issue, for bundling with mds reply */
366	struct ceph_mds_reply_cap {
367	__le32 caps, wanted; /* caps issued, wanted */
368	__le64 cap_id;
369	__le32 seq, mseq;
370	__le64 realm; /* snap realm */
371	__u8 flags; /* CEPH_CAP_FLAG_* */
372	} __attribute__ ((packed));
373
374	#define CEPH_CAP_FLAG_AUTH 1 /* cap is issued by auth mds */
375
376	/* inode record, for bundling with mds reply */
377	struct ceph_mds_reply_inode {
378	__le64 ino;
379	__le64 snapid;
380	__le32 rdev;
381	__le64 version; /* inode version */
382	__le64 xattr_version; /* version for xattr blob */
383	struct ceph_mds_reply_cap cap; /* caps issued for this inode */
384	struct ceph_file_layout layout;
385	struct ceph_timespec ctime, mtime, atime;
386	__le32 time_warp_seq;
387	__le64 size, max_size, truncate_size;
388	__le32 truncate_seq;
389	__le32 mode, uid, gid;
390	__le32 nlink;
391	__le64 files, subdirs, rbytes, rfiles, rsubdirs; /* dir stats */
392	struct ceph_timespec rctime;
393	struct ceph_frag_tree_head fragtree; /* (must be at end of struct) */
394	} __attribute__ ((packed));
395	/* followed by frag array, then symlink string, then xattr blob */
396
397	/* reply_lease follows dname, and reply_inode */
398	struct ceph_mds_reply_lease {
399	__le16 mask; /* lease type(s) */
400	__le32 duration_ms; /* lease duration */
401	__le32 seq;
402	} __attribute__ ((packed));
403
404	struct ceph_mds_reply_dirfrag {
405	__le32 frag; /* fragment */
406	__le32 auth; /* auth mds, if this is a delegation point */
407	__le32 ndist; /* number of mds' this is replicated on */
408	__le32 dist[];
409	} __attribute__ ((packed));
410
411	/* file access modes */
412	#define CEPH_FILE_MODE_PIN 0
413	#define CEPH_FILE_MODE_RD 1
414	#define CEPH_FILE_MODE_WR 2
415	#define CEPH_FILE_MODE_RDWR 3 /* RD \| WR */
416	#define CEPH_FILE_MODE_LAZY 4 /* lazy io */
417	#define CEPH_FILE_MODE_NUM 8 /* bc these are bit fields.. mostly */
418
419	int ceph_flags_to_mode(int flags);
420
421
422	/* capability bits */
423	#define CEPH_CAP_PIN 1 /* no specific capabilities beyond the pin */
424
425	/* generic cap bits */
426	#define CEPH_CAP_GSHARED 1 /* client can reads */
427	#define CEPH_CAP_GEXCL 2 /* client can read and update */
428	#define CEPH_CAP_GCACHE 4 /* (file) client can cache reads */
429	#define CEPH_CAP_GRD 8 /* (file) client can read */
430	#define CEPH_CAP_GWR 16 /* (file) client can write */
431	#define CEPH_CAP_GBUFFER 32 /* (file) client can buffer writes */
432	#define CEPH_CAP_GWREXTEND 64 /* (file) client can extend EOF */
433	#define CEPH_CAP_GLAZYIO 128 /* (file) client can perform lazy io */
434
435	/* per-lock shift */
436	#define CEPH_CAP_SAUTH 2
437	#define CEPH_CAP_SLINK 4
438	#define CEPH_CAP_SXATTR 6
439	#define CEPH_CAP_SFILE 8 /* goes at the end (uses >2 cap bits) */
440
441	#define CEPH_CAP_BITS 16
442
443	/* composed values */
444	#define CEPH_CAP_AUTH_SHARED (CEPH_CAP_GSHARED << CEPH_CAP_SAUTH)
445	#define CEPH_CAP_AUTH_EXCL (CEPH_CAP_GEXCL << CEPH_CAP_SAUTH)
446	#define CEPH_CAP_LINK_SHARED (CEPH_CAP_GSHARED << CEPH_CAP_SLINK)
447	#define CEPH_CAP_LINK_EXCL (CEPH_CAP_GEXCL << CEPH_CAP_SLINK)
448	#define CEPH_CAP_XATTR_SHARED (CEPH_CAP_GSHARED << CEPH_CAP_SXATTR)
449	#define CEPH_CAP_XATTR_EXCL (CEPH_CAP_GEXCL << CEPH_CAP_SXATTR)
450	#define CEPH_CAP_FILE(x) (x << CEPH_CAP_SFILE)
451	#define CEPH_CAP_FILE_SHARED (CEPH_CAP_GSHARED << CEPH_CAP_SFILE)
452	#define CEPH_CAP_FILE_EXCL (CEPH_CAP_GEXCL << CEPH_CAP_SFILE)
453	#define CEPH_CAP_FILE_CACHE (CEPH_CAP_GCACHE << CEPH_CAP_SFILE)
454	#define CEPH_CAP_FILE_RD (CEPH_CAP_GRD << CEPH_CAP_SFILE)
455	#define CEPH_CAP_FILE_WR (CEPH_CAP_GWR << CEPH_CAP_SFILE)
456	#define CEPH_CAP_FILE_BUFFER (CEPH_CAP_GBUFFER << CEPH_CAP_SFILE)
457	#define CEPH_CAP_FILE_WREXTEND (CEPH_CAP_GWREXTEND << CEPH_CAP_SFILE)
458	#define CEPH_CAP_FILE_LAZYIO (CEPH_CAP_GLAZYIO << CEPH_CAP_SFILE)
459
460	/* cap masks (for getattr) */
461	#define CEPH_STAT_CAP_INODE CEPH_CAP_PIN
462	#define CEPH_STAT_CAP_TYPE CEPH_CAP_PIN /* mode >> 12 */
463	#define CEPH_STAT_CAP_SYMLINK CEPH_CAP_PIN
464	#define CEPH_STAT_CAP_UID CEPH_CAP_AUTH_SHARED
465	#define CEPH_STAT_CAP_GID CEPH_CAP_AUTH_SHARED
466	#define CEPH_STAT_CAP_MODE CEPH_CAP_AUTH_SHARED
467	#define CEPH_STAT_CAP_NLINK CEPH_CAP_LINK_SHARED
468	#define CEPH_STAT_CAP_LAYOUT CEPH_CAP_FILE_SHARED
469	#define CEPH_STAT_CAP_MTIME CEPH_CAP_FILE_SHARED
470	#define CEPH_STAT_CAP_SIZE CEPH_CAP_FILE_SHARED
471	#define CEPH_STAT_CAP_ATIME CEPH_CAP_FILE_SHARED /* fixme */
472	#define CEPH_STAT_CAP_XATTR CEPH_CAP_XATTR_SHARED
473	#define CEPH_STAT_CAP_INODE_ALL (CEPH_CAP_PIN \| \
474	CEPH_CAP_AUTH_SHARED \| \
475	CEPH_CAP_LINK_SHARED \| \
476	CEPH_CAP_FILE_SHARED \| \
477	CEPH_CAP_XATTR_SHARED)
478
479	#define CEPH_CAP_ANY_SHARED (CEPH_CAP_AUTH_SHARED \| \
480	CEPH_CAP_LINK_SHARED \| \
481	CEPH_CAP_XATTR_SHARED \| \
482	CEPH_CAP_FILE_SHARED)
483	#define CEPH_CAP_ANY_RD (CEPH_CAP_ANY_SHARED \| CEPH_CAP_FILE_RD \| \
484	CEPH_CAP_FILE_CACHE)
485
486	#define CEPH_CAP_ANY_EXCL (CEPH_CAP_AUTH_EXCL \| \
487	CEPH_CAP_LINK_EXCL \| \
488	CEPH_CAP_XATTR_EXCL \| \
489	CEPH_CAP_FILE_EXCL)
490	#define CEPH_CAP_ANY_FILE_WR (CEPH_CAP_FILE_WR \| CEPH_CAP_FILE_BUFFER \| \
491	CEPH_CAP_FILE_EXCL)
492	#define CEPH_CAP_ANY_WR (CEPH_CAP_ANY_EXCL \| CEPH_CAP_ANY_FILE_WR)
493	#define CEPH_CAP_ANY (CEPH_CAP_ANY_RD \| CEPH_CAP_ANY_EXCL \| \
494	CEPH_CAP_ANY_FILE_WR \| CEPH_CAP_PIN)
495
496	#define CEPH_CAP_LOCKS (CEPH_LOCK_IFILE \| CEPH_LOCK_IAUTH \| CEPH_LOCK_ILINK \| \
497	CEPH_LOCK_IXATTR)
498
499	int ceph_caps_for_mode(int mode);
500
501	enum {
502	CEPH_CAP_OP_GRANT, /* mds->client grant */
503	CEPH_CAP_OP_REVOKE, /* mds->client revoke */
504	CEPH_CAP_OP_TRUNC, /* mds->client trunc notify */
505	CEPH_CAP_OP_EXPORT, /* mds has exported the cap */
506	CEPH_CAP_OP_IMPORT, /* mds has imported the cap */
507	CEPH_CAP_OP_UPDATE, /* client->mds update */
508	CEPH_CAP_OP_DROP, /* client->mds drop cap bits */
509	CEPH_CAP_OP_FLUSH, /* client->mds cap writeback */
510	CEPH_CAP_OP_FLUSH_ACK, /* mds->client flushed */
511	CEPH_CAP_OP_FLUSHSNAP, /* client->mds flush snapped metadata */
512	CEPH_CAP_OP_FLUSHSNAP_ACK, /* mds->client flushed snapped metadata */
513	CEPH_CAP_OP_RELEASE, /* client->mds release (clean) cap */
514	CEPH_CAP_OP_RENEW, /* client->mds renewal request */
515	};
516
517	extern const char *ceph_cap_op_name(int op);
518
519	/*
520	* caps message, used for capability callbacks, acks, requests, etc.
521	*/
522	struct ceph_mds_caps {
523	__le32 op; /* CEPH_CAP_OP_* */
524	__le64 ino, realm;
525	__le64 cap_id;
526	__le32 seq, issue_seq;
527	__le32 caps, wanted, dirty; /* latest issued/wanted/dirty */
528	__le32 migrate_seq;
529	__le64 snap_follows;
530	__le32 snap_trace_len;
531	__le64 client_tid; /* for FLUSH(SNAP) -> FLUSH(SNAP)_ACK */
532
533	/* authlock */
534	__le32 uid, gid, mode;
535
536	/* linklock */
537	__le32 nlink;
538
539	/* xattrlock */
540	__le32 xattr_len;
541	__le64 xattr_version;
542
543	/* filelock */
544	__le64 size, max_size, truncate_size;
545	__le32 truncate_seq;
546	struct ceph_timespec mtime, atime, ctime;
547	struct ceph_file_layout layout;
548	__le32 time_warp_seq;
549	} __attribute__ ((packed));
550
551	/* cap release msg head */
552	struct ceph_mds_cap_release {
553	__le32 num; /* number of cap_items that follow */
554	} __attribute__ ((packed));
555
556	struct ceph_mds_cap_item {
557	__le64 ino;
558	__le64 cap_id;
559	__le32 migrate_seq, seq;
560	} __attribute__ ((packed));
561
562	#define CEPH_MDS_LEASE_REVOKE 1 /* mds -> client */
563	#define CEPH_MDS_LEASE_RELEASE 2 /* client -> mds */
564	#define CEPH_MDS_LEASE_RENEW 3 /* client <-> mds */
565	#define CEPH_MDS_LEASE_REVOKE_ACK 4 /* client -> mds */
566
567	extern const char *ceph_lease_op_name(int o);
568
569	/* lease msg header */
570	struct ceph_mds_lease {
571	__u8 action; /* CEPH_MDS_LEASE_* */
572	__le16 mask; /* which lease */
573	__le64 ino;
574	__le64 first, last; /* snap range */
575	__le32 seq;
576	__le32 duration_ms; /* duration of renewal */
577	} __attribute__ ((packed));
578	/* followed by a __le32+string for dname */
579
580	/* client reconnect */
581	struct ceph_mds_cap_reconnect {
582	__le64 cap_id;
583	__le32 wanted;
584	__le32 issued;
585	__le64 size;
586	struct ceph_timespec mtime, atime;
587	__le64 snaprealm;
588	__le64 pathbase; /* base ino for our path to this ino */
589	} __attribute__ ((packed));
590	/* followed by encoded string */
591
592	struct ceph_mds_snaprealm_reconnect {
593	__le64 ino; /* snap realm base */
594	__le64 seq; /* snap seq for this snap realm */
595	__le64 parent; /* parent realm */
596	} __attribute__ ((packed));
597
598	/*
599	* snaps
600	*/
601	enum {
602	CEPH_SNAP_OP_UPDATE, /* CREATE or DESTROY */
603	CEPH_SNAP_OP_CREATE,
604	CEPH_SNAP_OP_DESTROY,
605	CEPH_SNAP_OP_SPLIT,
606	};
607
608	extern const char *ceph_snap_op_name(int o);
609
610	/* snap msg header */
611	struct ceph_mds_snap_head {
612	__le32 op; /* CEPH_SNAP_OP_* */
613	__le64 split; /* ino to split off, if any */
614	__le32 num_split_inos; /* # inos belonging to new child realm */
615	__le32 num_split_realms; /* # child realms udner new child realm */
616	__le32 trace_len; /* size of snap trace blob */
617	} __attribute__ ((packed));
618	/* followed by split ino list, then split realms, then the trace blob */
619
620	/*
621	* encode info about a snaprealm, as viewed by a client
622	*/
623	struct ceph_mds_snap_realm {
624	__le64 ino; /* ino */
625	__le64 created; /* snap: when created */
626	__le64 parent; /* ino: parent realm */
627	__le64 parent_since; /* snap: same parent since */
628	__le64 seq; /* snap: version */
629	__le32 num_snaps;
630	__le32 num_prior_parent_snaps;
631	} __attribute__ ((packed));
632	/* followed by my snap list, then prior parent snap list */
633
634	#endif