diff options
Diffstat (limited to 'wireshark')
-rw-r--r-- | wireshark/wireshark.patch | 2846 |
1 files changed, 2846 insertions, 0 deletions
diff --git a/wireshark/wireshark.patch b/wireshark/wireshark.patch new file mode 100644 index 00000000000..0f8618f96e5 --- /dev/null +++ b/wireshark/wireshark.patch @@ -0,0 +1,2846 @@ +Index: configure.in +=================================================================== +--- configure.in (revision 26845) ++++ configure.in (working copy) +@@ -1671,6 +1671,7 @@ + plugins/agentx/Makefile + plugins/artnet/Makefile + plugins/asn1/Makefile ++ plugins/ceph/Makefile + plugins/ciscosm/Makefile + plugins/docsis/Makefile + plugins/enttec/Makefile +Index: Makefile.am +=================================================================== +--- Makefile.am (revision 26845) ++++ Makefile.am (working copy) +@@ -243,6 +243,7 @@ + -dlopen plugins/agentx/agentx.la \ + -dlopen plugins/artnet/artnet.la \ + -dlopen plugins/asn1/asn1.la \ ++ -dlopen plugins/ceph/ceph.la \ + -dlopen plugins/ciscosm/ciscosm.la \ + -dlopen plugins/docsis/docsis.la \ + -dlopen plugins/enttec/enttec.la \ +Index: plugins/ceph/plugin.c +=================================================================== +--- plugins/ceph/plugin.c (revision 0) ++++ plugins/ceph/plugin.c (revision 0) +@@ -0,0 +1,28 @@ ++/* Do not modify this file. */ ++/* It is created automatically by the Makefile. */ ++ ++#ifdef HAVE_CONFIG_H ++# include "config.h" ++#endif ++ ++#include <gmodule.h> ++ ++#include "moduleinfo.h" ++ ++#ifndef ENABLE_STATIC ++G_MODULE_EXPORT const gchar version[] = VERSION; ++ ++/* Start the functions we need for the plugin stuff */ ++ ++G_MODULE_EXPORT void ++plugin_register (void) ++{ ++ {extern void proto_register_ceph (void); proto_register_ceph ();} ++} ++ ++G_MODULE_EXPORT void ++plugin_reg_handoff(void) ++{ ++ {extern void proto_reg_handoff_ceph (void); proto_reg_handoff_ceph ();} ++} ++#endif +Index: plugins/ceph/Makefile.common +=================================================================== +--- plugins/ceph/Makefile.common (revision 0) ++++ plugins/ceph/Makefile.common (revision 0) +@@ -0,0 +1,31 @@ ++# Makefile.common for Cisco SS7 Session Management plugin ++# Contains the stuff from Makefile.am and Makefile.nmake that is ++# a) common to both files and ++# b) portable between both files ++# ++# $Id: Makefile.common 18197 2006-05-21 05:12:17Z sahlberg $ ++# ++# Wireshark - Network traffic analyzer ++# By Gerald Combs <gerald@wireshark.org> ++# Copyright 1998 Gerald Combs ++# ++# This program is free software; you can redistribute it and/or ++# modify it under the terms of the GNU General Public License ++# as published by the Free Software Foundation; either version 2 ++# of the License, or (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program; if not, write to the Free Software ++# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++ ++# the name of the plugin ++PLUGIN_NAME = ciscosm ++ ++# the dissector sources (without any helpers) ++DISSECTOR_SRC = \ ++ packet-ceph.c +Index: plugins/ceph/packet-ceph.c +=================================================================== +--- plugins/ceph/packet-ceph.c (revision 0) ++++ plugins/ceph/packet-ceph.c (revision 0) +@@ -0,0 +1,1141 @@ ++/* packet-ceph.c
++* This program is free software; you can redistribute it and/or
++* modify it under the terms of the GNU General Public License
++* as published by the Free Software Foundation; either version 2
++* of the License, or (at your option) any later version.
++*
++* This program is distributed in the hope that it will be useful,
++* but WITHOUT ANY WARRANTY; without even the implied warranty of
++* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++* GNU General Public License for more details.
++*
++* You should have received a copy of the GNU General Public License
++* along with this program; if not, write to the Free Software
++* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
++*/
++
++#ifdef HAVE_CONFIG_H
++# include "config.h"
++#endif
++
++#include <stdio.h>
++#include <glib.h>
++#include <epan/packet.h>
++#include <epan/dissectors/packet-tcp.h>
++
++// this is needed for ceph_fs to compile in userland
++#include <netinet/in.h>
++#if 0
++#define _LINUX_TYPES_H /* we don't want linux/types.h's __u32, __le32, etc. */
++#include "inttypes.h"
++#include "byteorder.h"
++#endif
++
++
++#include <linux/types.h>
++typedef int bool;
++
++#define le16_to_cpu(x) (x)
++#define le32_to_cpu(x) (x)
++#define le64_to_cpu(x) (x)
++
++#include <fcntl.h>
++#include <string.h>
++#include "ceph_fs.h"
++
++
++
++#include <string.h>
++
++#define PROTO_TAG_CEPH "CEPH"
++
++/* Wireshark ID of the CEPH protocol */
++static int proto_ceph = -1;
++
++
++
++/* These are the handles of our subdissectors */
++static dissector_handle_t data_handle=NULL;
++
++static dissector_handle_t ceph_handle;
++static void dissect_ceph(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
++
++static guint32 global_ceph_min_port = 12340;
++static guint32 global_ceph_max_port = 12369;
++
++static guint32 global_ceph_min_mon_port = 12340;
++static guint32 global_ceph_max_mon_port = 12349;
++static guint32 global_ceph_min_mds_port = 12350;
++static guint32 global_ceph_max_mds_port = 12359;
++static guint32 global_ceph_min_osd_port = 12360;
++static guint32 global_ceph_max_osd_port = 12369;
++
++#define DEST_PORT_CEPH ((pinfo->destport >= global_ceph_min_port) && (pinfo->destport <= global_ceph_max_port))
++
++#define PORT_IS_MON(port) ((port >= global_ceph_min_mon_port) && (port <= global_ceph_max_mon_port))
++#define PORT_IS_MDS(port) ((port >= global_ceph_min_mds_port) && (port <= global_ceph_max_mds_port))
++#define PORT_IS_OSD(port) ((port >= global_ceph_min_osd_port) && (port <= global_ceph_max_osd_port))
++
++#define IS_ENTITY(cmp, port1, port2) (cmp(port1) || cmp(port2))
++
++#define IS_MON(pinfo) IS_ENTITY(PORT_IS_MON, pinfo->srcport, pinfo->destport)
++#define IS_MDS(pinfo) IS_ENTITY(PORT_IS_MDS, pinfo->srcport, pinfo->destport)
++#define IS_OSD(pinfo) IS_ENTITY(PORT_IS_OSD, pinfo->srcport, pinfo->destport)
++
++#define MON_STR "mon"
++#define MDS_STR "mds"
++#define OSD_STR "osd"
++
++#define FMT_INO "0x%.16llx"
++
++#define PROTO_ADD_TEXT(type, s, field, modifier)\
++ proto_tree_add_text(tree, tvb, offset + offsetof(type, field), sizeof(s->field), "" #field ": " modifier, s->field);
++
++#define CTIME_BUF_LEN 128
++
++#define PROTO_ADD_TIME(tvb, tree, type, offset, head, field, name) \
++ do { \
++ char buf[CTIME_BUF_LEN]; \
++ time_t time; \
++ time = head->field.tv_sec; \
++ ctime_r(&time, buf); \
++ buf[strlen(buf)-1] = '\0'; \
++ proto_tree_add_text(tree, tvb, offset + offsetof(type, field), \
++ sizeof(head->field), "" #name ": %s (%d ns)", buf, head->field.tv_nsec); \
++ } while (0)
++
++static const value_string packettypenames[] = {
++ { 1, "Shutdown" },
++ { 2, "Ping" },
++ { 4, "Mon Map" },
++ { 5, "Mon Get Map" },
++ { 10, "Client Mount" },
++ { 11, "Client Unmount" },
++ { 12, "Statfs" },
++ { 13, "Statfs Reply" },
++ { 20, "MDS Get Map" },
++ { 21, "MDS Map" },
++ { 22, "Client Session" },
++ { 23, "Client Reconnect" },
++ { 24, "Client Request" },
++ { 25, "Client Request Forward" },
++ { 26, "Client Reply" },
++ { 0x310, "Client Caps" },
++ { 0x311, "Client Lease" },
++ { 0x312, "Client Snap" },
++ { 40, "OSD Get Map" },
++ { 41, "OSD Map" },
++ { 42, "OSD Op" },
++ { 43, "OSD Op Reply" },
++ { 0, NULL }
++};
++
++#define ACK_MSG_SIZE 5
++#define TVB_MSG_HEADER_POS(x) (1 + offsetof(struct ceph_msg_header, x))
++#define TVB_IS_ACK(ofs) (tvb_get_guint8(tvb, ofs) == CEPH_MSGR_TAG_ACK)
++#define TVB_MSG_FIELD(func, tvb, ofs, field) func(tvb, ofs + (TVB_IS_ACK(ofs) ? ACK_MSG_SIZE : 0) + TVB_MSG_HEADER_POS(field))
++
++/* The following hf_* variables are used to hold the Wireshark IDs of
++* our header fields; they are filled out when we call
++* proto_register_field_array() in proto_register_ceph()
++*/
++/** Kts attempt at defining the protocol */
++static gint hf_ceph = -1;
++static gint hf_ceph_mds_op = -1;
++static gint hf_ceph_header = -1;
++static gint hf_ceph_banner = -1;
++static gint hf_ceph_entity_addr = -1;
++static gint hf_ceph_entity_type = -1;
++static gint hf_ceph_entity_num = -1;
++static gint hf_ceph_fsid = -1;
++static gint hf_ceph_banner_magic = -1;
++static gint hf_ceph_banner_version = -1;
++static gint hf_ceph_connect_erank = -1;
++static gint hf_ceph_connect_nonce = -1;
++static gint hf_ceph_sockaddr_in = -1;
++static gint hf_ceph_connect_host_type = -1;
++static gint hf_ceph_connect_tag = -1;
++static gint hf_ceph_connect_global_seq = -1;
++static gint hf_ceph_connect_connect_seq = -1;
++static gint hf_ceph_connect_flags = -1;
++static gint hf_ceph_length = -1;
++static gint hf_ceph_type = -1;
++static gint hf_ceph_text = -1;
++static gint hf_ceph_path = -1;
++static gint hf_sin_family = -1;
++static gint hf_sin_port = -1;
++static gint hf_sin_addr = -1;
++static gint hf_ceph_hdr_tag = -1;
++static gint hf_ceph_hdr_seq_ack = -1;
++static gint hf_ceph_hdr_seq = -1;
++static gint hf_ceph_hdr_type = -1;
++static gint hf_ceph_hdr_priority = -1;
++static gint hf_ceph_hdr_mon_protocol = -1;
++static gint hf_ceph_hdr_osd_protocol = -1;
++static gint hf_ceph_hdr_mds_protocol = -1;
++static gint hf_ceph_hdr_client_protocol = -1;
++static gint hf_ceph_hdr_front_len = -1;
++static gint hf_ceph_hdr_data_off = -1;
++static gint hf_ceph_hdr_data_len = -1;
++static gint hf_ceph_data = -1;
++static gint hf_ceph_front = -1;
++static gint hf_ceph_hdr_src = -1;
++static gint hf_ceph_hdr_orig_src = -1;
++static gint hf_ceph_hdr_dst = -1;
++static gint hf_ceph_hdr_crc = -1;
++static gint hf_ceph_footer = -1;
++static gint hf_ceph_footer_flags = -1;
++static gint hf_ceph_footer_front_crc = -1;
++static gint hf_ceph_footer_data_crc = -1;
++
++
++/* These are the ids of the subtrees that we may be creating */
++static gint ett_ceph = -1;
++static gint ett_ceph_header = -1;
++static gint ett_ceph_banner = -1;
++static gint ett_ceph_entity_addr = -1;
++static gint ett_ceph_length = -1;
++static gint ett_ceph_type = -1;
++static gint ett_ceph_text = -1;
++static gint ett_ceph_front = -1;
++static gint ett_ceph_data = -1;
++static gint ett_ceph_footer = -1;
++
++
++void proto_reg_handoff_ceph(void)
++{
++ static gboolean initialized=FALSE;
++ static guint32 port;
++
++ if (!initialized) {
++ data_handle = find_dissector("data");
++ ceph_handle = create_dissector_handle(dissect_ceph, proto_ceph);
++ for (port = global_ceph_min_port; port <= global_ceph_max_port; port++)
++ dissector_add("tcp.port", port, ceph_handle);
++ }
++
++}
++
++void proto_register_ceph (void)
++{
++ /* A header field is something you can search/filter on.
++ *
++ * We create a structure to register our fields. It consists of an
++ * array of hf_register_info structures, each of which are of the format
++ * {&(field id), {name, abbrev, type, display, strings, bitmask, blurb, HFILL}}.
++ */
++ static hf_register_info hf[] = {
++ { &hf_ceph,
++ { "Data", "ceph.data", FT_NONE, BASE_NONE, NULL, 0x0,
++ "CEPH PDU", HFILL }},
++ { &hf_ceph_header,
++ { "Header", "ceph.header", FT_NONE, BASE_NONE, NULL, 0x0,
++ "CEPH Header", HFILL }},
++ { &hf_ceph_banner,
++ { "Ceph Banner", "ceph.connect.banner", FT_STRING, BASE_NONE, NULL, 0x0,
++ "Ceph Banner", HFILL }},
++ { &hf_ceph_entity_type,
++ { "Ceph Entity Type", "ceph.entity.type", FT_UINT32, BASE_DEC, NULL, 0x0,
++ "Ceph Entity Type", HFILL }},
++ { &hf_ceph_entity_num,
++ { "Ceph Entity Num", "ceph.entity.num", FT_UINT32, BASE_DEC, NULL, 0x0,
++ "Ceph Entity Num", HFILL }},
++ { &hf_ceph_entity_addr,
++ { "Ceph Entity Addr", "ceph.entity.addr", FT_NONE, BASE_NONE, NULL, 0x0,
++ "Ceph Entity Addr", HFILL }},
++ { &hf_ceph_fsid,
++ { "Ceph FSID", "ceph.fsid", FT_NONE, BASE_NONE, NULL, 0x0,
++ "Ceph FSID", HFILL }},
++ { &hf_ceph_banner_magic,
++ { "Ceph Banner Magic", "ceph.connect.banner.magic", FT_STRING, BASE_NONE, NULL, 0x0,
++ "Ceph Banner Magic", HFILL }},
++ { &hf_ceph_banner_version,
++ { "Ceph Banner Version", "ceph.connect.banner.ver", FT_STRING, BASE_NONE, NULL, 0x0,
++ "Ceph Banner", HFILL }},
++ { &hf_ceph_connect_erank,
++ { "erank", "ceph.connect.erank", FT_UINT32, BASE_HEX, NULL, 0x0,
++ "connect: erank", HFILL }},
++ { &hf_ceph_connect_nonce,
++ { "nonce", "ceph.connect.nonce", FT_UINT32, BASE_HEX, NULL, 0x0,
++ "connect: nonce", HFILL }},
++ { &hf_ceph_sockaddr_in,
++ { "sockaddr_in", "ceph.sockaddr_in", FT_NONE, BASE_NONE, NULL, 0x0,
++ "sockaddr_in", HFILL }},
++ { &hf_sin_family,
++ { "sin_family", "ceph.sin_family", FT_UINT16, BASE_HEX, NULL, 0x0,
++ "sockaddr_in: sin_family", HFILL }},
++ { &hf_sin_port,
++ { "sin_port", "ceph.sin_port", FT_UINT16, BASE_DEC, NULL, 0x0,
++ "sockaddr_in: sin_port", HFILL }},
++ { &hf_sin_addr,
++ { "ip addr", "ceph.addr", FT_IPv4, BASE_NONE, NULL, 0x0,
++ "sockaddr_in: ip addr", HFILL }},
++ { &hf_ceph_connect_host_type,
++ { "host_type", "ceph.connect.host_type", FT_UINT32, BASE_DEC, NULL, 0x0,
++ "connect: host_type", HFILL }},
++ { &hf_ceph_connect_tag,
++ { "tag", "ceph.connect.tag", FT_UINT8, BASE_DEC, NULL, 0x0,
++ "connect: tag", HFILL }},
++ { &hf_ceph_mds_op,
++ { "mds op", "ceph.mds.op", FT_UINT32, BASE_HEX, NULL, 0x0,
++ "ceph: mds op", HFILL }},
++ { &hf_ceph_connect_global_seq,
++ { "global_seq", "ceph.connect.global_seq", FT_UINT32, BASE_DEC, NULL, 0x0,
++ "connect: global_seq", HFILL }},
++ { &hf_ceph_connect_connect_seq,
++ { "connect_seq", "ceph.connect.connect_seq", FT_UINT32, BASE_DEC, NULL, 0x0,
++ "connect: connect_seq", HFILL }},
++ { &hf_ceph_connect_flags,
++ { "flags", "ceph.connect.flags", FT_UINT8, BASE_HEX, NULL, 0x0,
++ "connect: flags", HFILL }},
++ { &hf_ceph_length,
++ { "Package Length", "ceph.len", FT_UINT32, BASE_DEC, NULL, 0x0,
++ "Package Length", HFILL }},
++ { &hf_ceph_type,
++ { "Type", "ceph.type", FT_UINT8, BASE_DEC, VALS(packettypenames), 0x0,
++ "Package Type", HFILL }},
++ { &hf_ceph_text,
++ { "Text", "ceph.text", FT_STRING, BASE_NONE, NULL, 0x0,
++ "Text", HFILL }},
++ { &hf_ceph_path,
++ { "path", "ceph.path", FT_STRING, BASE_NONE, NULL, 0x0,
++ "path", HFILL }},
++ { &hf_ceph_hdr_tag,
++ { "tag", "ceph.tag", FT_UINT8, BASE_DEC, NULL, 0x0,
++ "hdr: tag", HFILL }},
++ { &hf_ceph_hdr_seq_ack,
++ { "ack seq", "ceph.ack.seq", FT_UINT32, BASE_DEC, NULL, 0x0,
++ "ack: seq", HFILL }},
++ { &hf_ceph_hdr_seq,
++ { "seq", "ceph.seq", FT_UINT64, BASE_DEC, NULL, 0x0,
++ "hdr: seq", HFILL }},
++ { &hf_ceph_hdr_type,
++ { "type", "ceph.type", FT_UINT16, BASE_HEX, NULL, 0x0,
++ "hdr: type", HFILL }},
++ { &hf_ceph_hdr_priority,
++ { "priority", "ceph.priority", FT_UINT16, BASE_DEC, NULL, 0x0,
++ "hdr: priority", HFILL }},
++ { &hf_ceph_hdr_mon_protocol,
++ { "mon_protocol", "ceph.mon_protocol", FT_UINT16, BASE_DEC, NULL, 0x0,
++ "hdr: mon_protocol", HFILL }},
++ { &hf_ceph_hdr_osd_protocol,
++ { "osd_protocol", "ceph.osd_protocol", FT_UINT16, BASE_DEC, NULL, 0x0,
++ "hdr: osd_protocol", HFILL }},
++ { &hf_ceph_hdr_mds_protocol,
++ { "mds_protocol", "ceph.mds_protocol", FT_UINT16, BASE_DEC, NULL, 0x0,
++ "hdr: mds_protocol", HFILL }},
++ { &hf_ceph_hdr_client_protocol,
++ { "client_protocol", "ceph.client_protocol", FT_UINT16, BASE_DEC, NULL, 0x0,
++ "hdr: client_protocol", HFILL }},
++ { &hf_ceph_hdr_front_len,
++ { "front_len", "ceph.front_len", FT_UINT32, BASE_DEC, NULL, 0x0,
++ "hdr: front_len", HFILL }},
++ { &hf_ceph_hdr_data_off,
++ { "data_off", "ceph.data_off", FT_UINT32, BASE_DEC, NULL, 0x0,
++ "hdr: data_off", HFILL }},
++ { &hf_ceph_hdr_data_len,
++ { "data_len", "ceph.data_len", FT_UINT32, BASE_DEC, NULL, 0x0,
++ "hdr: data_len", HFILL }},
++ { &hf_ceph_hdr_src,
++ { "src", "ceph.src", FT_NONE, BASE_NONE, NULL, 0x0,
++ "hdr: src", HFILL }},
++ { &hf_ceph_hdr_orig_src,
++ { "orig_src", "ceph.orig_src", FT_NONE, BASE_NONE, NULL, 0x0,
++ "hdr: orig_src", HFILL }},
++ { &hf_ceph_hdr_dst,
++ { "dst", "ceph.dst", FT_NONE, BASE_NONE, NULL, 0x0,
++ "hdr: dst", HFILL }},
++ { &hf_ceph_hdr_crc,
++ { "crc", "ceph.crc", FT_UINT32, BASE_HEX, NULL, 0x0,
++ "hdr: crc", HFILL }},
++ { &hf_ceph_front,
++ { "Front", "ceph.front", FT_NONE, BASE_NONE, NULL, 0x0,
++ "Ceph Front", HFILL }},
++ { &hf_ceph_data,
++ { "Data", "ceph.data", FT_NONE, BASE_HEX, NULL, 0x0,
++ "Ceph Data", HFILL }},
++ { &hf_ceph_footer,
++ { "Footer", "ceph.footer", FT_NONE, BASE_HEX, NULL, 0x0,
++ "Ceph Footer", HFILL }},
++ { &hf_ceph_footer_flags,
++ { "flags", "ceph.footer.flags", FT_UINT32, BASE_HEX, NULL, 0x0,
++ "footer: flags", HFILL }},
++ { &hf_ceph_footer_front_crc,
++ { "front_crc", "ceph.footer.front_crc", FT_UINT32, BASE_HEX, NULL, 0x0,
++ "footer: front_crc", HFILL }},
++ { &hf_ceph_footer_data_crc,
++ { "data_crc", "ceph.footer.data_crc", FT_UINT32, BASE_HEX, NULL, 0x0,
++ "footer: data_crc", HFILL }},
++ };
++ static gint *ett[] = {
++ &ett_ceph,
++ &ett_ceph_header,
++ &ett_ceph_banner,
++ &ett_ceph_length,
++ &ett_ceph_entity_addr,
++ &ett_ceph_type,
++ &ett_ceph_text,
++ &ett_ceph_data,
++ &ett_ceph_front,
++ &ett_ceph_footer
++ };
++ //if (proto_ceph == -1) { /* execute protocol initialization only once */
++ proto_ceph = proto_register_protocol ("CEPH Protocol", "CEPH", "ceph");
++
++ proto_register_field_array (proto_ceph, hf, array_length (hf));
++ proto_register_subtree_array (ett, array_length (ett));
++ register_dissector("ceph", dissect_ceph, proto_ceph);
++ //}
++}
++
++static guint32 dissect_sockaddr_in(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
++{
++ proto_tree *ceph_sockaddr_tree = NULL;
++ proto_item *ceph_sub_item = NULL;
++ proto_item *ceph_item = proto_tree_get_parent(tree);
++
++ ceph_sockaddr_tree = proto_item_add_subtree(ceph_item, ett_ceph);
++
++ ceph_sub_item = proto_tree_add_item( tree, hf_ceph_sockaddr_in, tvb, offset, 16, TRUE );
++ ceph_sockaddr_tree = proto_item_add_subtree(ceph_sub_item, ett_ceph);
++
++ proto_tree_add_item(ceph_sockaddr_tree, hf_sin_family, tvb, offset, 2, TRUE);
++ proto_tree_add_item(ceph_sockaddr_tree, hf_sin_port, tvb, offset+2, 2, TRUE);
++ proto_tree_add_item(ceph_sockaddr_tree, hf_sin_addr, tvb, offset+4, 4, FALSE);
++ offset += 16;
++ return offset;
++}
++
++static guint32 dissect_ceph_banner(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
++{
++ proto_tree *ceph_banner_tree = NULL;
++ proto_item *ceph_sub_item = NULL;
++
++ ceph_sub_item = proto_tree_add_item( tree, hf_ceph_banner, tvb, offset, 8, TRUE );
++ ceph_banner_tree = proto_item_add_subtree(ceph_sub_item, ett_ceph);
++
++ proto_tree_add_item(ceph_banner_tree, hf_ceph_banner_magic, tvb, offset, 4, TRUE);
++ proto_tree_add_item(ceph_banner_tree, hf_ceph_banner_version, tvb, offset+4, 4, TRUE);
++
++ return offset+9;
++}
++
++static guint32 dissect_ceph_entity_addr(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
++{
++ proto_tree *ceph_entity_tree = NULL;
++ proto_item *ceph_sub_item = NULL;
++
++ ceph_sub_item = proto_tree_add_item( tree, hf_ceph_entity_addr, tvb, offset, sizeof(struct ceph_entity_addr), TRUE );
++ ceph_entity_tree = proto_item_add_subtree(ceph_sub_item, ett_ceph);
++ proto_tree_add_item(ceph_entity_tree, hf_ceph_connect_erank, tvb, offset, 4, TRUE);
++ proto_tree_add_item(ceph_entity_tree, hf_ceph_connect_nonce, tvb, offset+4, 4, TRUE);
++ offset = dissect_sockaddr_in(tvb, ceph_entity_tree, offset+8);
++#if 0
++ proto_tree_add_item(ceph_entity_tree, hf_ceph_connect_host_type, tvb, offset, 4, TRUE);
++ offset += 4;
++#endif
++
++ return offset;
++}
++
++static guint32 dissect_ceph_fsid(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
++{
++ proto_tree *ceph_entity_tree = NULL;
++ proto_item *ceph_sub_item = NULL;
++ struct ceph_fsid *fsid;
++
++ fsid = (struct ceph_fsid *)tvb_get_ptr(tvb, offset, sizeof(struct ceph_fsid));
++
++ ceph_sub_item = proto_tree_add_item( tree, hf_ceph_fsid, tvb, offset, sizeof(struct ceph_entity_addr), TRUE );
++ ceph_entity_tree = proto_item_add_subtree(ceph_sub_item, ett_ceph);
++
++ proto_tree_add_item(ceph_entity_tree, hf_ceph_connect_erank, tvb, offset, 4, TRUE);
++ proto_tree_add_item(ceph_entity_tree, hf_ceph_connect_nonce, tvb, offset+4, 4, TRUE);
++
++ proto_tree_add_text(tree, tvb, offsetof(struct ceph_fsid, major),
++ sizeof(fsid->major), "major: " FMT_INO, fsid->major);
++ proto_tree_add_text(tree, tvb, offsetof(struct ceph_fsid, minor),
++ sizeof(fsid->minor), "minor: " FMT_INO, fsid->minor);
++
++ offset += sizeof(struct ceph_fsid);
++
++ return offset;
++}
++
++static guint32 dissect_ceph_entity_inst(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
++{
++ proto_tree *ceph_entity_tree = NULL;
++ proto_item *ceph_sub_item = NULL;
++
++ ceph_sub_item = proto_tree_add_item( tree, hf_ceph_entity_addr, tvb, offset, sizeof(struct ceph_entity_addr), TRUE );
++ ceph_entity_tree = proto_item_add_subtree(ceph_sub_item, ett_ceph);
++ proto_tree_add_item(ceph_entity_tree, hf_ceph_entity_type, tvb, offset, 4, TRUE);
++ proto_tree_add_item(ceph_entity_tree, hf_ceph_entity_num, tvb, offset+4, 4, TRUE);
++ offset += 8;
++ offset = dissect_ceph_entity_addr(tvb, ceph_entity_tree, offset);
++ return offset;
++}
++
++static guint32 dissect_ceph_footer(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
++{
++ proto_tree *ceph_footer_tree = NULL;
++ proto_item *ceph_sub_item = NULL;
++
++ ceph_sub_item = proto_tree_add_item( tree, hf_ceph_footer, tvb, offset, sizeof(struct ceph_msg_footer), TRUE );
++ ceph_footer_tree = proto_item_add_subtree(ceph_sub_item, ett_ceph);
++ proto_tree_add_item(ceph_footer_tree, hf_ceph_footer_flags, tvb, offset, 4, TRUE);
++ proto_tree_add_item(ceph_footer_tree, hf_ceph_footer_front_crc, tvb, offset+4, 4, TRUE);
++ proto_tree_add_item(ceph_footer_tree, hf_ceph_footer_data_crc, tvb, offset+8, 4, TRUE);
++ offset += 12;
++ return offset;
++}
++
++static guint32 dissect_ceph_client_connect(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
++{
++ proto_tree *ceph_header_tree = NULL;
++ proto_item *ceph_sub_item = NULL;
++ proto_item *ceph_item = proto_tree_get_parent(tree);
++
++ offset = dissect_ceph_banner(tvb, tree, offset);
++
++ ceph_header_tree = proto_item_add_subtree(ceph_item, ett_ceph);
++
++ ceph_sub_item = proto_tree_add_item( tree, hf_ceph_header, tvb, offset, -1, TRUE );
++ ceph_header_tree = proto_item_add_subtree(ceph_sub_item, ett_ceph);
++
++ offset = dissect_ceph_entity_addr(tvb, ceph_header_tree, offset);
++ proto_tree_add_item(ceph_header_tree, hf_ceph_connect_host_type, tvb, offset, 4, TRUE);
++ offset += 4;
++ proto_tree_add_item(ceph_header_tree, hf_ceph_connect_global_seq, tvb, offset, 4, TRUE);
++ proto_tree_add_item(ceph_header_tree, hf_ceph_connect_connect_seq, tvb, offset+4, 4, TRUE);
++ proto_tree_add_item(ceph_header_tree, hf_ceph_connect_flags, tvb, offset+8, 1, TRUE);
++ offset += 8;
++ return offset;
++}
++
++static guint32 dissect_ceph_server_connect(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
++{
++ proto_tree *ceph_header_tree = NULL;
++ proto_item *ceph_sub_item = NULL;
++ proto_item *ceph_item = proto_tree_get_parent(tree);
++
++ offset = dissect_ceph_banner(tvb, tree, offset);
++
++ ceph_header_tree = proto_item_add_subtree(ceph_item, ett_ceph);
++
++ ceph_sub_item = proto_tree_add_item( tree, hf_ceph_header, tvb, offset, -1, TRUE );
++ ceph_header_tree = proto_item_add_subtree(ceph_sub_item, ett_ceph);
++
++ offset = dissect_ceph_entity_addr(tvb, ceph_header_tree, offset);
++
++ proto_tree_add_item(ceph_header_tree, hf_ceph_hdr_tag, tvb, offset, 1, TRUE);
++ offset += 1;
++ proto_tree_add_item(ceph_header_tree, hf_ceph_connect_global_seq, tvb, offset, 4, TRUE);
++ proto_tree_add_item(ceph_header_tree, hf_ceph_connect_connect_seq, tvb, offset+4, 4, TRUE);
++ proto_tree_add_item(ceph_header_tree, hf_ceph_connect_flags, tvb, offset+8, 1, TRUE);
++ return offset;
++}
++
++static guint32 dissect_ceph_file_layout(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
++{
++ guint32 orig_ofs = offset;
++ struct ceph_file_layout *lo;
++
++ lo = (struct ceph_file_layout *)tvb_get_ptr(tvb, offset, sizeof(struct ceph_file_layout));
++
++ PROTO_ADD_TEXT(struct ceph_file_layout, lo, fl_stripe_unit, "%d");
++ PROTO_ADD_TEXT(struct ceph_file_layout, lo, fl_stripe_count, "%d");
++ PROTO_ADD_TEXT(struct ceph_file_layout, lo, fl_object_size, "%d");
++ PROTO_ADD_TEXT(struct ceph_file_layout, lo, fl_cas_hash, "%d");
++ PROTO_ADD_TEXT(struct ceph_file_layout, lo, fl_object_stripe_unit, "%d");
++ PROTO_ADD_TEXT(struct ceph_file_layout, lo, fl_pg_preferred, "%d");
++ PROTO_ADD_TEXT(struct ceph_file_layout, lo, fl_pg_type, "%u");
++ PROTO_ADD_TEXT(struct ceph_file_layout, lo, fl_pg_size, "%u");
++ PROTO_ADD_TEXT(struct ceph_file_layout, lo, fl_pg_pool, "%u");
++
++ return orig_ofs + sizeof(struct ceph_mds_reply_head);
++}
++
++static int dissect_ceph_filepath(tvbuff_t *tvb, proto_tree *tree, guint32 offset, char **path, guint64 *ino)
++{
++ guint32 len;
++ const char *p = NULL;
++
++ *ino = tvb_get_letoh64(tvb, offset);
++ proto_tree_add_text(tree, tvb, offset, sizeof(*ino), "inode: " FMT_INO, *ino);
++ offset += sizeof(*ino);
++ len = tvb_get_letohl(tvb, offset);
++ proto_tree_add_text(tree, tvb, offset, sizeof(len), "len: %d", len);
++ offset += sizeof(len);
++
++ if (len) {
++ p = tvb_get_ptr(tvb, offset, len);
++ *path = malloc(len+1);
++ if (*path) {
++ memcpy(*path, p, len);
++ (*path)[len] = '\0';
++ proto_tree_add_item(tree, hf_ceph_path, tvb, offset, len, TRUE);
++ }
++ }
++
++ offset += len;
++
++ return offset;
++}
++
++static guint32 dissect_ceph_mon_statfs(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
++{
++ struct ceph_mon_statfs *req;
++
++ req = (struct ceph_mon_statfs *)tvb_get_ptr(tvb, offset, sizeof(struct ceph_mon_statfs));
++
++ dissect_ceph_fsid(tvb, tree, offset + offsetof(struct ceph_mon_statfs, fsid));
++ PROTO_ADD_TEXT(struct ceph_mon_statfs, req, tid, "%lld");
++
++ return offset + sizeof(struct ceph_mon_statfs);
++}
++
++static guint32 dissect_ceph_mon_statfs_reply(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
++{
++ struct ceph_mon_statfs_reply *req;
++
++ req = (struct ceph_mon_statfs_reply *)tvb_get_ptr(tvb, offset, sizeof(struct ceph_mon_statfs_reply));
++
++ dissect_ceph_fsid(tvb, tree, offset + offsetof(struct ceph_mon_statfs_reply, fsid));
++ PROTO_ADD_TEXT(struct ceph_mon_statfs_reply, req, tid, "%lld");
++ PROTO_ADD_TEXT(struct ceph_mon_statfs_reply, req, st.f_total, "%lld");
++ PROTO_ADD_TEXT(struct ceph_mon_statfs_reply, req, st.f_free, "%lld");
++ PROTO_ADD_TEXT(struct ceph_mon_statfs_reply, req, st.f_avail, "%lld");
++ PROTO_ADD_TEXT(struct ceph_mon_statfs_reply, req, st.f_objects, "%lld");
++
++ return offset + sizeof(struct ceph_mon_statfs_reply);
++}
++
++static guint32 dissect_ceph_client_osd_getmap(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
++{
++ struct ceph_osd_getmap *req;
++
++ req = (struct ceph_osd_getmap *)tvb_get_ptr(tvb, offset, sizeof(struct ceph_osd_getmap));
++
++ dissect_ceph_fsid(tvb, tree, offset + offsetof(struct ceph_osd_getmap, fsid));
++ PROTO_ADD_TEXT(struct ceph_osd_getmap, req, start, "%d");
++
++ return offset + sizeof(struct ceph_osd_getmap);
++}
++
++static guint32 dissect_ceph_client_mds_getmap(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
++{
++ struct ceph_mds_getmap *req;
++
++ req = (struct ceph_mds_getmap *)tvb_get_ptr(tvb, offset, sizeof(struct ceph_mds_getmap));
++
++ dissect_ceph_fsid(tvb, tree, offset + offsetof(struct ceph_mds_getmap, fsid));
++ PROTO_ADD_TEXT(struct ceph_mds_getmap, req, want, "%d");
++
++ return offset + sizeof(struct ceph_mds_getmap);
++}
++
++static guint32 dissect_ceph_client_mds_request(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset)
++{
++ struct ceph_mds_request_head *head;
++ proto_item *item;
++
++ head = (struct ceph_mds_request_head *)tvb_get_ptr(tvb, offset, sizeof(struct ceph_mds_request_head));
++
++ PROTO_ADD_TEXT(struct ceph_mds_request_head, head, tid, "%lld");
++ PROTO_ADD_TEXT(struct ceph_mds_request_head, head, oldest_client_tid, "%lld");
++ PROTO_ADD_TEXT(struct ceph_mds_request_head, head, mdsmap_epoch, "%d");
++ PROTO_ADD_TEXT(struct ceph_mds_request_head, head, num_fwd, "%d");
++ PROTO_ADD_TEXT(struct ceph_mds_request_head, head, retry_attempt, "%d");
++ PROTO_ADD_TEXT(struct ceph_mds_request_head, head, mds_wants_replica_in_dirino, "%lld");
++
++ item = proto_tree_add_item(tree, hf_ceph_mds_op, tvb, offset+offsetof(struct ceph_mds_request_head, op), sizeof(head->op), TRUE);
++ proto_item_append_text(item, " (%s)", ceph_mds_op_name(head->op));
++
++ PROTO_ADD_TEXT(struct ceph_mds_request_head, head, caller_uid, "%d");
++ PROTO_ADD_TEXT(struct ceph_mds_request_head, head, caller_gid, "%d");
++
++ if (check_col(pinfo->cinfo, COL_INFO)) {
++ col_append_fstr(pinfo->cinfo, COL_INFO, " (%s)", ceph_mds_op_name(head->op));
++ }
++
++ switch (head->op) {
++ case CEPH_MDS_OP_FINDINODE:
++ break;
++ case CEPH_MDS_OP_STAT:
++ case CEPH_MDS_OP_LSTAT:
++ PROTO_ADD_TEXT(struct ceph_mds_request_head, head, args.stat.mask, "0x%.4x");
++ break;
++ case CEPH_MDS_OP_LUTIME:
++ case CEPH_MDS_OP_UTIME:
++#define MDS_REQ_ADD_TIME(field) PROTO_ADD_TIME(tvb, tree, struct ceph_mds_request_head, offset, head, args.utime.field, field)
++ MDS_REQ_ADD_TIME(mtime);
++ MDS_REQ_ADD_TIME(atime);
++ MDS_REQ_ADD_TIME(ctime);
++ break;
++ case CEPH_MDS_OP_CHMOD:
++ case CEPH_MDS_OP_LCHMOD:
++ PROTO_ADD_TEXT(struct ceph_mds_request_head, head, args.chmod.mode, "0%.5o");
++ break;
++ case CEPH_MDS_OP_CHOWN:
++ case CEPH_MDS_OP_LCHOWN:
++ PROTO_ADD_TEXT(struct ceph_mds_request_head, head, args.chown.uid, "%d");
++ PROTO_ADD_TEXT(struct ceph_mds_request_head, head, args.chown.gid, "%d");
++ PROTO_ADD_TEXT(struct ceph_mds_request_head, head, args.chown.mask, "0x%.4x");
++ break;
++ case CEPH_MDS_OP_LSETLAYOUT:
++ dissect_ceph_file_layout(tvb, tree, offset + offsetof(struct ceph_mds_request_head, args.setlayout.layout));
++ break;
++ case CEPH_MDS_OP_SETXATTR:
++ case CEPH_MDS_OP_LSETXATTR:
++ PROTO_ADD_TEXT(struct ceph_mds_request_head, head, args.setxattr.flags, "0x%.4x");
++ break;
++ case CEPH_MDS_OP_READDIR:
++ PROTO_ADD_TEXT(struct ceph_mds_request_head, head, args.readdir.frag, "%d");
++ break;
++ case CEPH_MDS_OP_MKNOD:
++ PROTO_ADD_TEXT(struct ceph_mds_request_head, head, args.mknod.mode, "0%.5o");
++ PROTO_ADD_TEXT(struct ceph_mds_request_head, head, args.mknod.rdev, "%d");
++ break;
++ case CEPH_MDS_OP_OPEN:
++ PROTO_ADD_TEXT(struct ceph_mds_request_head, head, args.open.flags, "%x");
++ PROTO_ADD_TEXT(struct ceph_mds_request_head, head, args.open.mode, "0%.5o");
++ break;
++ case CEPH_MDS_OP_LTRUNCATE:
++ case CEPH_MDS_OP_TRUNCATE:
++ PROTO_ADD_TEXT(struct ceph_mds_request_head, head, args.truncate.length, "%lld");
++ break;
++ case CEPH_MDS_OP_MKDIR:
++ PROTO_ADD_TEXT(struct ceph_mds_request_head, head, args.mkdir.mode, "0%.5o");
++ break;
++ case CEPH_MDS_OP_RMXATTR:
++ case CEPH_MDS_OP_LRMXATTR:
++ case CEPH_MDS_OP_LINK:
++ case CEPH_MDS_OP_UNLINK:
++ case CEPH_MDS_OP_RENAME:
++ case CEPH_MDS_OP_RMDIR:
++ case CEPH_MDS_OP_SYMLINK:
++ case CEPH_MDS_OP_FSYNC:
++ case CEPH_MDS_OP_LSSNAP:
++ case CEPH_MDS_OP_MKSNAP:
++ case CEPH_MDS_OP_RMSNAP:
++ break;
++ }
++
++ offset += sizeof(struct ceph_mds_request_head);
++
++ if (head->op == CEPH_MDS_OP_FINDINODE) {
++
++ } else {
++ guint64 ino1, ino2;
++ char *s1 = NULL, *s2 = NULL;
++
++ offset = dissect_ceph_filepath(tvb, tree, offset, &s1, &ino1);
++ offset = dissect_ceph_filepath(tvb, tree, offset, &s2, &ino2);
++
++ if (check_col(pinfo->cinfo, COL_INFO)) {
++ if (s1)
++ col_append_fstr(pinfo->cinfo, COL_INFO, " %s", s1);
++ if (s2)
++ col_append_fstr(pinfo->cinfo, COL_INFO, " -> %s", s2);
++ }
++
++
++
++ }
++
++ return offset;
++}
++
++static guint32 dissect_ceph_client_mds_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset)
++{
++ guint32 orig_ofs = offset;
++ struct ceph_mds_reply_head *head;
++
++ head = (struct ceph_mds_reply_head *)tvb_get_ptr(tvb, offset, sizeof(struct ceph_mds_reply_head));
++
++ PROTO_ADD_TEXT(struct ceph_mds_reply_head, head, tid, "%lld");
++
++ proto_tree_add_text(tree, tvb, offsetof(struct ceph_mds_reply_head, op),
++ sizeof(head->op), "op: %d (%s)", head->op, ceph_mds_op_name(head->op));
++
++ PROTO_ADD_TEXT(struct ceph_mds_reply_head, head, result, "%d");
++ PROTO_ADD_TEXT(struct ceph_mds_reply_head, head, file_caps, "%d");
++ PROTO_ADD_TEXT(struct ceph_mds_reply_head, head, file_caps_seq, "%d");
++ PROTO_ADD_TEXT(struct ceph_mds_reply_head, head, file_caps_mseq, "%d");
++ PROTO_ADD_TEXT(struct ceph_mds_reply_head, head, mdsmap_epoch, "%d");
++
++
++ if (check_col(pinfo->cinfo, COL_INFO)) {
++ col_append_fstr(pinfo->cinfo, COL_INFO, " (%s)", ceph_mds_op_name(head->op));
++ }
++
++ return orig_ofs + sizeof(struct ceph_mds_reply_head);
++}
++
++static guint32 dissect_ceph_client_mds_lease_request(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset)
++{
++ guint32 orig_ofs = offset;
++ struct ceph_mds_lease *head;
++ static char *lease_action[] = { "", "revoke", "release", "renew" };
++
++ head = (struct ceph_mds_lease *)tvb_get_ptr(tvb, offset, sizeof(struct ceph_mds_lease));
++
++ PROTO_ADD_TEXT(struct ceph_mds_lease, head, action, "%d");
++ PROTO_ADD_TEXT(struct ceph_mds_lease, head, mask, "%.4x");
++ PROTO_ADD_TEXT(struct ceph_mds_lease, head, ino, FMT_INO);
++ PROTO_ADD_TEXT(struct ceph_mds_lease, head, first, "%lld");
++ PROTO_ADD_TEXT(struct ceph_mds_lease, head, last, "%lld");
++
++ if (check_col(pinfo->cinfo, COL_INFO)) {
++ if (head->action < 4) {
++ col_append_fstr(pinfo->cinfo, COL_INFO, " (%s)", lease_action[head->action]);
++ }
++ }
++
++ return orig_ofs + sizeof(struct ceph_mds_lease);
++}
++
++static guint32 dissect_ceph_client_mds_caps_request(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset)
++{
++ guint32 orig_ofs = offset;
++ struct ceph_mds_caps *head;
++
++ head = (struct ceph_mds_caps *)tvb_get_ptr(tvb, offset, sizeof(struct ceph_mds_caps));
++
++ PROTO_ADD_TEXT(struct ceph_mds_caps, head, op, "%d");
++ PROTO_ADD_TEXT(struct ceph_mds_caps, head, ino, FMT_INO);
++ PROTO_ADD_TEXT(struct ceph_mds_caps, head, seq, "%d");
++ PROTO_ADD_TEXT(struct ceph_mds_caps, head, caps, "%d");
++ PROTO_ADD_TEXT(struct ceph_mds_caps, head, wanted, "%d");
++ PROTO_ADD_TEXT(struct ceph_mds_caps, head, size, "%llu");
++ PROTO_ADD_TEXT(struct ceph_mds_caps, head, max_size, "%llu");
++ PROTO_ADD_TEXT(struct ceph_mds_caps, head, truncate_seq, "%lld");
++ PROTO_ADD_TEXT(struct ceph_mds_caps, head, migrate_seq, "%d");
++ PROTO_ADD_TEXT(struct ceph_mds_caps, head, time_warp_seq, "%llu");
++ PROTO_ADD_TEXT(struct ceph_mds_caps, head, snap_follows, "%llu");
++ PROTO_ADD_TEXT(struct ceph_mds_caps, head, snap_trace_len, "%d");
++
++#define CAPS_REQ_ADD_TIME(field) PROTO_ADD_TIME(tvb, tree, struct ceph_mds_caps, offset, head, field, field)
++ CAPS_REQ_ADD_TIME(mtime);
++ CAPS_REQ_ADD_TIME(atime);
++ CAPS_REQ_ADD_TIME(ctime);
++
++ if (check_col(pinfo->cinfo, COL_INFO)) {
++ col_append_fstr(pinfo->cinfo, COL_INFO, " (%s)", ceph_cap_op_name(head->op));
++ }
++
++ return orig_ofs + sizeof(struct ceph_mds_caps);
++}
++
++static guint32 dissect_ceph_client_front(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint16 type)
++{
++ switch (type) {
++ case CEPH_MSG_STATFS:
++ offset = dissect_ceph_mon_statfs(tvb, tree, offset);
++ break;
++ case CEPH_MSG_STATFS_REPLY:
++ offset = dissect_ceph_mon_statfs_reply(tvb, tree, offset);
++ break;
++ case CEPH_MSG_CLIENT_REQUEST: /* mds request */
++ offset = dissect_ceph_client_mds_request(tvb, pinfo, tree, offset);
++ break;
++ case CEPH_MSG_CLIENT_REPLY:
++ offset = dissect_ceph_client_mds_reply(tvb, pinfo, tree, offset);
++ break;
++ case CEPH_MSG_CLIENT_LEASE:
++ offset = dissect_ceph_client_mds_lease_request(tvb, pinfo, tree, offset);
++ break;
++ case CEPH_MSG_CLIENT_CAPS:
++ offset = dissect_ceph_client_mds_caps_request(tvb, pinfo, tree, offset);
++ break;
++ case CEPH_MSG_OSD_GETMAP:
++ offset = dissect_ceph_client_osd_getmap(tvb, tree, offset);
++ break;
++ case CEPH_MSG_MDS_GETMAP:
++ offset = dissect_ceph_client_mds_getmap(tvb, tree, offset);
++ break;
++ default:
++ break;
++ }
++ return offset;
++}
++
++static guint32 dissect_ceph_generic(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset)
++{
++ proto_tree *ceph_header_tree = NULL;
++ proto_item *ceph_sub_item = NULL;
++ proto_item *ceph_item = proto_tree_get_parent(tree);
++ guint32 front_len, data_len;
++ guint8 tag;
++ guint32 orig_ofs = offset;
++ guint16 type;
++ guint64 seq;
++
++ ceph_header_tree = proto_item_add_subtree(ceph_item, ett_ceph);
++
++ ceph_sub_item = proto_tree_add_item( tree, hf_ceph_header, tvb, offset, -1, TRUE );
++ ceph_header_tree = proto_item_add_subtree(ceph_sub_item, ett_ceph);
++
++ tag = tvb_get_guint8(tvb, offset);
++
++ if (tag == CEPH_MSGR_TAG_ACK) {
++ proto_tree_add_item(ceph_header_tree, hf_ceph_hdr_tag, tvb, offset, 1, TRUE);
++ proto_tree_add_item(ceph_header_tree, hf_ceph_hdr_seq_ack, tvb, offset+1, 4, TRUE);
++ offset += ACK_MSG_SIZE;
++ }
++
++ proto_tree_add_item(ceph_header_tree, hf_ceph_hdr_tag, tvb, offset, 1, TRUE);
++ proto_tree_add_item(ceph_header_tree, hf_ceph_hdr_seq, tvb, offset+1, 8, TRUE);
++ offset += 9;
++ proto_tree_add_item(ceph_header_tree, hf_ceph_hdr_type, tvb, offset, 2, TRUE);
++ offset += 2;
++ proto_tree_add_item(ceph_header_tree, hf_ceph_hdr_priority, tvb, offset, 2, TRUE);
++ proto_tree_add_item(ceph_header_tree, hf_ceph_hdr_mon_protocol, tvb, offset+2, 2, TRUE);
++ proto_tree_add_item(ceph_header_tree, hf_ceph_hdr_osd_protocol, tvb, offset+4, 2, TRUE);
++ proto_tree_add_item(ceph_header_tree, hf_ceph_hdr_mds_protocol, tvb, offset+6, 2, TRUE);
++ proto_tree_add_item(ceph_header_tree, hf_ceph_hdr_client_protocol, tvb, offset+8, 2, TRUE);
++ offset += 10;
++ proto_tree_add_item(ceph_header_tree, hf_ceph_hdr_front_len, tvb, offset, 4, TRUE);
++ proto_tree_add_item(ceph_header_tree, hf_ceph_hdr_data_off, tvb, offset+4, 4, TRUE);
++ proto_tree_add_item(ceph_header_tree, hf_ceph_hdr_data_len, tvb, offset+8, 4, TRUE);
++ offset += 12;
++ offset = dissect_ceph_entity_inst(tvb, ceph_header_tree, offset);
++ offset = dissect_ceph_entity_inst(tvb, ceph_header_tree, offset);
++ offset = dissect_ceph_entity_inst(tvb, ceph_header_tree, offset);
++ proto_tree_add_item(ceph_header_tree, hf_ceph_hdr_crc, tvb, offset, 4, TRUE);
++ offset += 4;
++
++ front_len = TVB_MSG_FIELD(tvb_get_letohs, tvb, orig_ofs, front_len);
++ type = TVB_MSG_FIELD(tvb_get_letohl, tvb, orig_ofs, type);
++
++ seq = TVB_MSG_FIELD(tvb_get_letoh64, tvb, orig_ofs, seq);
++
++ if (front_len) {
++ /* ceph_sub_item = proto_tree_add_item( tree, hf_ceph_front, tvb, offset, front_len, TRUE );
++ offset += front_len; */
++
++ offset = dissect_ceph_client_front(tvb, pinfo, tree, offset, type);
++/*
++ } else {
++ ceph_sub_item = proto_tree_add_item( tree, hf_ceph_front, tvb, offset, front_len, TRUE );
++ offset += front_len;
++ } */
++ }
++
++ data_len = TVB_MSG_FIELD(tvb_get_letohl, tvb, orig_ofs, data_len);
++ if (data_len) {
++ ceph_sub_item = proto_tree_add_item( tree, hf_ceph_data, tvb, offset, data_len, TRUE );
++ offset += data_len;
++ }
++
++ offset = dissect_ceph_footer(tvb, tree, offset);
++
++ return offset;
++}
++
++static void
++dissect_ceph_client(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
++{
++
++ proto_item *ceph_item = NULL;
++ proto_tree *ceph_tree = NULL;
++ guint16 type = 0;
++ const guchar *ptr;
++ guint32 pos = 0;
++ int have_banner = 0;
++
++ if (check_col(pinfo->cinfo, COL_PROTOCOL))
++ col_set_str(pinfo->cinfo, COL_PROTOCOL, PROTO_TAG_CEPH);
++ /* Clear out stuff in the info column */
++ if(check_col(pinfo->cinfo,COL_INFO)){
++ col_clear(pinfo->cinfo,COL_INFO);
++ }
++
++ ptr = tvb_get_ptr(tvb, pos, 9);
++ if (ptr && memcmp(ptr, "ceph", 4) == 0) {
++ have_banner = 1;
++ pos += 9;
++ }
++
++ // This is not a good way of dissecting packets. The tvb length should
++ // be sanity checked so we aren't going past the actual size of the buffer.
++ type = tvb_get_guint8( tvb, 4 ); // Get the type byte
++
++ if (check_col(pinfo->cinfo, COL_INFO)) {
++ char *entity_str = NULL;
++ if (IS_MON(pinfo))
++ entity_str = MON_STR;
++ else if (IS_MDS(pinfo))
++ entity_str = MDS_STR;
++ else if (IS_OSD(pinfo))
++ entity_str = OSD_STR;
++ else
++ entity_str = "???";
++ if (have_banner) {
++ col_add_fstr(pinfo->cinfo, COL_INFO, "[%s] Connect Request", entity_str);
++ } else {
++ type = TVB_MSG_FIELD(tvb_get_letohl, tvb, 0, type);
++ col_add_fstr(pinfo->cinfo, COL_INFO, "[%s] %s",
++ entity_str,
++ val_to_str(type, packettypenames, "Unknown Type:0x%02x"));
++ }
++ }
++
++ if (tree) { /* we are being asked for details */
++ guint32 offset = 0;
++
++ ceph_item = proto_tree_add_item(tree, proto_ceph, tvb, 0, -1, TRUE);
++ ceph_tree = proto_item_add_subtree(ceph_item, ett_ceph);
++ if (have_banner) { /* this is a connect message */
++ offset = dissect_ceph_client_connect(tvb, ceph_tree, offset);
++ } else {
++ offset = dissect_ceph_generic(tvb, pinfo, ceph_tree, offset);
++ }
++ }
++}
++
++static void
++dissect_ceph_server(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
++{
++
++ proto_item *ceph_item = NULL;
++ proto_tree *ceph_tree = NULL;
++ guint16 type = 0;
++ const guchar *ptr;
++ guint32 pos = 0;
++ int have_banner = 0;
++
++ if (check_col(pinfo->cinfo, COL_PROTOCOL))
++ col_set_str(pinfo->cinfo, COL_PROTOCOL, PROTO_TAG_CEPH);
++ /* Clear out stuff in the info column */
++ if(check_col(pinfo->cinfo,COL_INFO)){
++ col_clear(pinfo->cinfo,COL_INFO);
++ }
++
++ ptr = tvb_get_ptr(tvb, pos, 9);
++ if (ptr && memcmp(ptr, "ceph", 4) == 0) {
++ have_banner = 1;
++ pos += 9;
++ }
++
++ // This is not a good way of dissecting packets. The tvb length should
++ // be sanity checked so we aren't going past the actual size of the buffer.
++ type = tvb_get_guint8( tvb, 4 ); // Get the type byte
++
++ if (check_col(pinfo->cinfo, COL_INFO)) {
++ char *entity_str = NULL;
++ if (IS_MON(pinfo))
++ entity_str = MON_STR;
++ else if (IS_MDS(pinfo))
++ entity_str = MDS_STR;
++ else if (IS_OSD(pinfo))
++ entity_str = OSD_STR;
++ else
++ entity_str = "???";
++ if (have_banner) {
++ col_add_fstr(pinfo->cinfo, COL_INFO, "[%s] Connect Response", entity_str);
++ } else {
++ type = TVB_MSG_FIELD(tvb_get_letohl, tvb, 0, type);
++ col_add_fstr(pinfo->cinfo, COL_INFO, "[%s] %s",
++ entity_str,
++ val_to_str(type, packettypenames, "Unknown Type:0x%02x"));
++ }
++ }
++
++ if (tree) { /* we are being asked for details */
++ guint32 offset = 0;
++
++ ceph_item = proto_tree_add_item(tree, proto_ceph, tvb, 0, -1, TRUE);
++ ceph_tree = proto_item_add_subtree(ceph_item, ett_ceph);
++
++ if (have_banner) {
++ offset = dissect_ceph_server_connect(tvb, ceph_tree, offset);
++ } else {
++ offset = dissect_ceph_generic(tvb, pinfo, ceph_tree, offset);
++ }
++ }
++}
++
++static void
++dissect_ceph_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
++{
++ if (DEST_PORT_CEPH)
++ dissect_ceph_client(tvb, pinfo, tree);
++ else
++ dissect_ceph_server(tvb, pinfo, tree);
++}
++
++static guint dissect_ceph_acks(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
++{
++ guint32 offset = 0;
++
++ if (check_col(pinfo->cinfo, COL_PROTOCOL))
++ col_set_str(pinfo->cinfo, COL_PROTOCOL, PROTO_TAG_CEPH);
++ /* Clear out stuff in the info column */
++ if(check_col(pinfo->cinfo,COL_INFO)){
++ col_clear(pinfo->cinfo,COL_INFO);
++ col_add_fstr(pinfo->cinfo, COL_INFO, "Ack");
++ }
++ if (tree) {
++ proto_tree_add_item(tree, proto_ceph, tvb, 0, 5, TRUE);
++ proto_tree_add_item(tree, hf_ceph_hdr_tag, tvb, offset, 1, TRUE);
++ proto_tree_add_item(tree, hf_ceph_hdr_seq_ack, tvb, offset+1, 4, TRUE);
++ offset += 5;
++ }
++
++ return offset;
++}
++
++/* determine PDU length of protocol ceph */
++static guint get_ceph_message_len(packet_info *pinfo, tvbuff_t *tvb, int offset)
++{
++ const char *ptr;
++ guint32 len;
++ guint32 pos = 0;
++
++ ptr = tvb_get_ptr(tvb, offset, /* sizeof(CEPH_BANNER) */tvb->length-offset);
++ if (ptr && memcmp(ptr, "ceph", 4) == 0) {
++ if (DEST_PORT_CEPH) {
++ len = sizeof(CEPH_BANNER) - 1 +
++ sizeof(struct ceph_entity_addr) +
++ sizeof(struct ceph_msg_connect);
++ } else
++ len = sizeof(CEPH_BANNER) - 1 +
++ sizeof(struct ceph_entity_addr) +
++ sizeof(struct ceph_msg_connect_reply);
++
++ return len;
++ }
++
++ if (*ptr == CEPH_MSGR_TAG_ACK)
++ pos = ACK_MSG_SIZE;
++
++ len = pos + (guint)1 + sizeof(struct ceph_msg_header) +
++ TVB_MSG_FIELD(tvb_get_letohl, tvb, offset, front_len) +
++ TVB_MSG_FIELD(tvb_get_letohl, tvb, offset, data_len) +
++ sizeof(struct ceph_msg_footer);
++
++ if (!*ptr)
++ return 0;
++ return len;
++}
++
++
++static void dissect_ceph(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
++{
++ const char *ptr;
++
++ ptr = tvb_get_ptr(tvb, 0, 6);
++
++ if ((*ptr == CEPH_MSGR_TAG_MSG) ||
++ (memcmp(ptr, CEPH_BANNER, 4) == 0) ||
++ ((ptr[0] == CEPH_MSGR_TAG_ACK) && (ptr[5] == CEPH_MSGR_TAG_MSG))
++ ) {
++ tcp_dissect_pdus(tvb, pinfo, tree, TRUE, TVB_MSG_HEADER_POS(src),
++ get_ceph_message_len, dissect_ceph_message);
++ } else {
++ dissect_ceph_acks(tvb, pinfo, tree);
++ }
++}
++
+Index: plugins/ceph/plugin.rc.in +=================================================================== +--- plugins/ceph/plugin.rc.in (revision 0) ++++ plugins/ceph/plugin.rc.in (revision 0) +@@ -0,0 +1,34 @@ ++#include "winver.h"
++
++VS_VERSION_INFO VERSIONINFO
++ FILEVERSION @RC_MODULE_VERSION@
++ PRODUCTVERSION @RC_VERSION@,0
++ FILEFLAGSMASK 0x0L
++#ifdef _DEBUG
++ FILEFLAGS VS_FF_PRERELEASE+VS_FF_DEBUG
++#else
++ FILEFLAGS VS_FF_PRERELEASE
++#endif
++ FILEOS VOS_NT_WINDOWS32
++ FILETYPE VFT_DLL
++BEGIN
++ BLOCK "StringFileInfo"
++ BEGIN
++ BLOCK "040904b0"
++ BEGIN
++ VALUE "CompanyName", "The Wireshark developer community, http://www.wireshark.org/\0"
++ VALUE "FileDescription", "@PACKAGE@ dissector\0"
++ VALUE "FileVersion", "@MODULE_VERSION@\0"
++ VALUE "InternalName", "@PACKAGE@ @MODULE_VERSION@\0"
++ VALUE "LegalCopyright", "Copyright © 1998 Gerald Combs <gerald@wireshark.org>, Gilbert Ramirez <gram@alumni.rice.edu> and others\0"
++ VALUE "OriginalFilename", "@PLUGIN_NAME@.dll\0"
++ VALUE "ProductName", "Wireshark\0"
++ VALUE "ProductVersion", "@VERSION@\0"
++ VALUE "Comments", "Build with @MSVC_VARIANT@\0"
++ END
++ END
++ BLOCK "VarFileInfo"
++ BEGIN
++ VALUE "Translation", 0x409, 1200
++ END
++END
+Index: plugins/ceph/Makefile.nmake +=================================================================== +--- plugins/ceph/Makefile.nmake (revision 0) ++++ plugins/ceph/Makefile.nmake (revision 0) +@@ -0,0 +1,100 @@ ++# Makefile.nmake ++# nmake file for Wireshark plugin ++# ++# $Id: Makefile.nmake 24520 2008-03-01 12:31:01Z jake $ ++# ++ ++include ..\..\config.nmake ++include moduleinfo.nmake ++ ++include Makefile.common ++ ++CFLAGS=/WX /DHAVE_CONFIG_H /I../.. /I../../wiretap $(GLIB_CFLAGS) \ ++ /I$(PCAP_DIR)\include -D_U_="" $(LOCAL_CFLAGS) ++ ++.c.obj:: ++ $(CC) $(CFLAGS) -Fd.\ -c $< ++ ++LDFLAGS = $(PLUGIN_LDFLAGS) ++ ++!IFDEF ENABLE_LIBWIRESHARK ++LINK_PLUGIN_WITH=..\..\epan\libwireshark.lib ++CFLAGS=/DHAVE_WIN32_LIBWIRESHARK_LIB /D_NEED_VAR_IMPORT_ $(CFLAGS) ++ ++DISSECTOR_OBJECTS = $(DISSECTOR_SRC:.c=.obj) ++ ++DISSECTOR_SUPPORT_OBJECTS = $(DISSECTOR_SUPPORT_SRC:.c=.obj) ++ ++OBJECTS = $(DISSECTOR_OBJECTS) $(DISSECTOR_SUPPORT_OBJECTS) plugin.obj ++ ++RESOURCE=$(PLUGIN_NAME).res ++ ++all: $(PLUGIN_NAME).dll ++ ++$(PLUGIN_NAME).rc : moduleinfo.nmake ++ sed -e s/@PLUGIN_NAME@/$(PLUGIN_NAME)/ \ ++ -e s/@RC_MODULE_VERSION@/$(RC_MODULE_VERSION)/ \ ++ -e s/@RC_VERSION@/$(RC_VERSION)/ \ ++ -e s/@MODULE_VERSION@/$(MODULE_VERSION)/ \ ++ -e s/@PACKAGE@/$(PACKAGE)/ \ ++ -e s/@VERSION@/$(VERSION)/ \ ++ -e s/@MSVC_VARIANT@/$(MSVC_VARIANT)/ \ ++ < plugin.rc.in > $@ ++ ++$(PLUGIN_NAME).dll $(PLUGIN_NAME).exp $(PLUGIN_NAME).lib : $(OBJECTS) $(LINK_PLUGIN_WITH) $(RESOURCE) ++ link -dll /out:$(PLUGIN_NAME).dll $(LDFLAGS) $(OBJECTS) $(LINK_PLUGIN_WITH) \ ++ $(GLIB_LIBS) $(RESOURCE) ++ ++# ++# Build plugin.c, which contains the plugin version[] string, a ++# function plugin_register() that calls the register routines for all ++# protocols, and a function plugin_reg_handoff() that calls the handoff ++# registration routines for all protocols. ++# ++# We do this by scanning sources. If that turns out to be too slow, ++# maybe we could just require every .o file to have an register routine ++# of a given name (packet-aarp.o -> proto_register_aarp, etc.). ++# ++# Formatting conventions: The name of the proto_register_* routines an ++# proto_reg_handoff_* routines must start in column zero, or must be ++# preceded only by "void " starting in column zero, and must not be ++# inside #if. ++# ++# DISSECTOR_SRC is assumed to have all the files that need to be scanned. ++# ++# For some unknown reason, having a big "for" loop in the Makefile ++# to scan all the files doesn't work with some "make"s; they seem to ++# pass only the first few names in the list to the shell, for some ++# reason. ++# ++# Therefore, we have a script to generate the plugin.c file. ++# The shell script runs slowly, as multiple greps and seds are run ++# for each input file; this is especially slow on Windows. Therefore, ++# if Python is present (as indicated by PYTHON being defined), we run ++# a faster Python script to do that work instead. ++# ++# The first argument is the directory in which the source files live. ++# The second argument is "plugin", to indicate that we should build ++# a plugin.c file for a plugin. ++# All subsequent arguments are the files to scan. ++# ++!IFDEF PYTHON ++plugin.c: $(DISSECTOR_SRC) moduleinfo.h ../../tools/make-dissector-reg.py ++ @echo Making plugin.c (using python) ++ @$(PYTHON) "../../tools/make-dissector-reg.py" . plugin $(DISSECTOR_SRC) ++!ELSE ++plugin.c: $(DISSECTOR_SRC) moduleinfo.h ../../tools/make-dissector-reg ++ @echo Making plugin.c (using sh) ++ @$(SH) ../../tools/make-dissector-reg . plugin $(DISSECTOR_SRC) ++!ENDIF ++ ++!ENDIF ++ ++clean: ++ rm -f $(OBJECTS) $(RESOURCE) plugin.c *.pdb \ ++ $(PLUGIN_NAME).dll $(PLUGIN_NAME).dll.manifest $(PLUGIN_NAME).lib \ ++ $(PLUGIN_NAME).exp $(PLUGIN_NAME).rc ++ ++distclean: clean ++ ++maintainer-clean: distclean +Index: plugins/ceph/moduleinfo.h +=================================================================== +--- plugins/ceph/moduleinfo.h (revision 0) ++++ plugins/ceph/moduleinfo.h (revision 0) +@@ -0,0 +1,16 @@ ++/* Included *after* config.h, in order to re-define these macros */ ++ ++#ifdef PACKAGE ++#undef PACKAGE ++#endif ++ ++/* Name of package */ ++#define PACKAGE "ceph" ++ ++ ++#ifdef VERSION ++#undef VERSION ++#endif ++ ++/* Version number of package */ ++#define VERSION "0.0.1" +Index: plugins/ceph/Makefile.am +=================================================================== +--- plugins/ceph/Makefile.am (revision 0) ++++ plugins/ceph/Makefile.am (revision 0) +@@ -0,0 +1,126 @@ ++# Makefile.am ++# Automake file for Cisco SS7 Session Management plugin ++# Copyright 2004, Duncan Sargeant <dunc-ethereal@rcpt.to> ++# ++# $Id: Makefile.am 24488 2008-02-27 16:18:30Z stig $ ++# ++# Wireshark - Network traffic analyzer ++# By Gerald Combs <gerald@wireshark.org> ++# Copyright 1998 Gerald Combs ++# ++# This program is free software; you can redistribute it and/or ++# modify it under the terms of the GNU General Public License ++# as published by the Free Software Foundation; either version 2 ++# of the License, or (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program; if not, write to the Free Software ++# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++# ++ ++INCLUDES = -I$(top_srcdir) -I$(includedir) ++ ++include Makefile.common ++ ++ ++if HAVE_WARNINGS_AS_ERRORS ++AM_CFLAGS = -Werror ++endif ++ ++plugindir = @plugindir@ ++ ++plugin_LTLIBRARIES = ceph.la ++ceph_la_SOURCES = \ ++ plugin.c \ ++ moduleinfo.h \ ++ $(DISSECTOR_SRC) \ ++ $(DISSECTOR_INCLUDES) ++ceph_la_LDFLAGS = -module -avoid-version ++ceph_la_LIBADD = @PLUGIN_LIBS@ ++ ++# Libs must be cleared, or else libtool won't create a shared module. ++# If your module needs to be linked against any particular libraries, ++# add them here. ++LIBS = ++ ++# ++# Build plugin.c, which contains the plugin version[] string, a ++# function plugin_register() that calls the register routines for all ++# protocols, and a function plugin_reg_handoff() that calls the handoff ++# registration routines for all protocols. ++# ++# We do this by scanning sources. If that turns out to be too slow, ++# maybe we could just require every .o file to have an register routine ++# of a given name (packet-aarp.o -> proto_register_aarp, etc.). ++# ++# Formatting conventions: The name of the proto_register_* routines an ++# proto_reg_handoff_* routines must start in column zero, or must be ++# preceded only by "void " starting in column zero, and must not be ++# inside #if. ++# ++# DISSECTOR_SRC is assumed to have all the files that need to be scanned. ++# ++# For some unknown reason, having a big "for" loop in the Makefile ++# to scan all the files doesn't work with some "make"s; they seem to ++# pass only the first few names in the list to the shell, for some ++# reason. ++# ++# Therefore, we have a script to generate the plugin.c file. ++# The shell script runs slowly, as multiple greps and seds are run ++# for each input file; this is especially slow on Windows. Therefore, ++# if Python is present (as indicated by PYTHON being defined), we run ++# a faster Python script to do that work instead. ++# ++# The first argument is the directory in which the source files live. ++# The second argument is "plugin", to indicate that we should build ++# a plugin.c file for a plugin. ++# All subsequent arguments are the files to scan. ++# ++plugin.c: $(DISSECTOR_SRC) $(top_srcdir)/tools/make-dissector-reg \ ++ $(top_srcdir)/tools/make-dissector-reg.py ++ @if test -n "$(PYTHON)"; then \ ++ echo Making plugin.c with python ; \ ++ $(PYTHON) $(top_srcdir)/tools/make-dissector-reg.py $(srcdir) \ ++ plugin $(DISSECTOR_SRC) ; \ ++ else \ ++ echo Making plugin.c with shell script ; \ ++ $(top_srcdir)/tools/make-dissector-reg $(srcdir) \ ++ $(plugin_src) plugin $(DISSECTOR_SRC) ; \ ++ fi ++ ++# ++# Currently plugin.c can be included in the distribution because ++# we always build all protocol dissectors. We used to have to check ++# whether or not to build the snmp dissector. If we again need to ++# variably build something, making plugin.c non-portable, uncomment ++# the dist-hook line below. ++# ++# Oh, yuk. We don't want to include "plugin.c" in the distribution, as ++# its contents depend on the configuration, and therefore we want it ++# to be built when the first "make" is done; however, Automake insists ++# on putting *all* source into the distribution. ++# ++# We work around this by having a "dist-hook" rule that deletes ++# "plugin.c", so that "dist" won't pick it up. ++# ++#dist-hook: ++# @rm -f $(distdir)/plugin.c ++ ++CLEANFILES = \ ++ ceph \ ++ *~ ++ ++MAINTAINERCLEANFILES = \ ++ Makefile.in \ ++ plugin.c ++ ++EXTRA_DIST = \ ++ Makefile.common \ ++ Makefile.nmake \ ++ moduleinfo.nmake \ ++ plugin.rc.in +Index: plugins/ceph/moduleinfo.nmake +=================================================================== +--- plugins/ceph/moduleinfo.nmake (revision 0) ++++ plugins/ceph/moduleinfo.nmake (revision 0) +@@ -0,0 +1,28 @@ ++# ++# $Id: moduleinfo.nmake 20158 2006-12-19 22:23:37Z jake $ ++# ++ ++# The name ++PACKAGE=ceph ++ ++# The version ++MODULE_VERSION_MAJOR=0 ++MODULE_VERSION_MINOR=0 ++MODULE_VERSION_MICRO=1 ++MODULE_VERSION_EXTRA=0 ++ ++# ++# The RC_VERSION should be comma-separated, not dot-separated, ++# as per Graham Bloice's message in ++# ++# http://www.ethereal.com/lists/ethereal-dev/200303/msg00283.html ++# ++# "The RC_VERSION variable in config.nmake should be comma separated. ++# This allows the resources to be built correctly and the version ++# number to be correctly displayed in the explorer properties dialog ++# for the executables, and XP's tooltip, rather than 0.0.0.0." ++# ++ ++MODULE_VERSION=$(MODULE_VERSION_MAJOR).$(MODULE_VERSION_MINOR).$(MODULE_VERSION_MICRO).$(MODULE_VERSION_EXTRA) ++RC_MODULE_VERSION=$(MODULE_VERSION_MAJOR),$(MODULE_VERSION_MINOR),$(MODULE_VERSION_MICRO),$(MODULE_VERSION_EXTRA) ++ +Index: plugins/ceph/ceph_fs.h +=================================================================== +--- plugins/ceph/ceph_fs.h (revision 0) ++++ plugins/ceph/ceph_fs.h (revision 0) +@@ -0,0 +1,1225 @@ ++/* ++ * ceph_fs.h - Ceph constants and data types to share between kernel and ++ * user space. ++ * ++ * LGPL2 ++ */ ++ ++#ifndef _FS_CEPH_CEPH_FS_H ++#define _FS_CEPH_CEPH_FS_H ++ ++ ++#define CEPH_MON_PORT 12345 ++ ++/* ++ * Max file size is a policy choice; in reality we are limited ++ * by 2^64. ++ */ ++#define CEPH_FILE_MAX_SIZE (1ULL << 40) /* 1 TB */ ++ ++/* ++ * tcp connection banner. include a protocol version. and adjust ++ * whenever the wire protocol changes. try to keep this string length ++ * constant. ++ */ ++#define CEPH_BANNER "ceph 008\n" ++#define CEPH_BANNER_MAX_LEN 30 ++ ++/* ++ * subprotocol versions. when specific messages types or high-level ++ * protocols change, bump the affected components. ++ */ ++#define CEPH_OSD_PROTOCOL 3 ++#define CEPH_MDS_PROTOCOL 2 ++#define CEPH_MON_PROTOCOL 2 ++#define CEPH_CLIENT_PROTOCOL 1 ++#define CEPH_ONDISK_FORMAT 1 ++ ++/* ++ * 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. ++ */ ++ ++/* ++ * some basics ++ */ ++typedef __le64 ceph_version_t; ++typedef __le64 ceph_tid_t; /* transaction id */ ++typedef __le32 ceph_epoch_t; ++ ++ ++/* ++ * fs id ++ */ ++struct ceph_fsid { ++ __le64 major; ++ __le64 minor; ++} __attribute__ ((packed)); ++ ++static inline int ceph_fsid_equal(const struct ceph_fsid *a, ++ const struct ceph_fsid *b) ++{ ++ return a->major == b->major && a->minor == b->minor; ++} ++ ++ ++/* ++ * ino, object, etc. ++ */ ++#define CEPH_INO_ROOT 1 ++ ++typedef __le64 ceph_snapid_t; ++#define CEPH_MAXSNAP ((__u64)(-3)) ++#define CEPH_SNAPDIR ((__u64)(-1)) ++#define CEPH_NOSNAP ((__u64)(-2)) ++ ++struct ceph_object { ++ union { ++ __u8 raw[20]; /* fits a sha1 hash */ ++ struct { ++ __le64 ino; /* inode "file" identifier */ ++ __le32 bno; /* "block" (object) in that "file" */ ++ __le64 snap; /* snapshot id. usually NOSNAP. */ ++ } __attribute__ ((packed)); ++ }; ++} __attribute__ ((packed)); ++ ++struct ceph_timespec { ++ __le32 tv_sec; ++ __le32 tv_nsec; ++} __attribute__ ((packed)); ++ ++ ++/* ++ * "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; ++} ++ ++/* ++ * object layout - how objects are mapped into PGs ++ */ ++#define CEPH_OBJECT_LAYOUT_HASH 1 ++#define CEPH_OBJECT_LAYOUT_LINEAR 2 ++#define CEPH_OBJECT_LAYOUT_HASHINO 3 ++ ++/* ++ * pg layout -- how PGs are mapped onto (sets of) OSDs ++ */ ++#define CEPH_PG_LAYOUT_CRUSH 0 ++#define CEPH_PG_LAYOUT_HASH 1 ++#define CEPH_PG_LAYOUT_LINEAR 2 ++#define CEPH_PG_LAYOUT_HYBRID 3 ++ ++/* ++ * 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) */ ++ __u8 fl_pg_type; /* pg type; see PG_TYPE_* */ ++ __u8 fl_pg_size; /* pg size (num replicas, etc.) */ ++ __u8 fl_pg_pool; /* implies crush ruleset AND object namespace */ ++} __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_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)) ++ ++/* ++ * 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 */ ++ __u8 __pad; ++ __u8 size; ++ __u8 pool; /* implies crush ruleset */ ++ __u8 type; ++ } 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) ++ ++/* ++ * stable_mod func is used to control number of placement groups. ++ * similar to straight-up modulo, but produces a stable mapping as b ++ * increases over time. b is the number of bins, and bmask is the ++ * containing power of 2 minus 1. ++ * ++ * b <= bmask and bmask=(2**n)-1 ++ * e.g., b=12 -> bmask=15, b=123 -> bmask=127 ++ */ ++static inline int ceph_stable_mod(int x, int b, int bmask) ++{ ++ if ((x & bmask) < b) ++ return x & bmask; ++ else ++ return x & (bmask >> 1); ++} ++ ++/* ++ * object layout - how a given object should be stored. ++ */ ++struct ceph_object_layout { ++ __le64 ol_pgid; /* raw pg, with _full_ ps precision. */ ++ __le32 ol_stripe_unit; ++} __attribute__ ((packed)); ++ ++/* ++ * compound epoch+version, used by storage layer to serialize mutations ++ */ ++struct ceph_eversion { ++ ceph_epoch_t epoch; ++ __le64 version; ++} __attribute__ ((packed)); ++ ++/* ++ * osd map bits ++ */ ++ ++/* status bits */ ++#define CEPH_OSD_EXISTS 1 ++#define CEPH_OSD_UP 2 ++#define CEPH_OSD_CLEAN 4 /* as in, clean shutdown */ ++ ++/* osd weights. fixed point value: 0x10000 == 1.0 ("in"), 0 == "out" */ ++#define CEPH_OSD_IN 0x10000 ++#define CEPH_OSD_OUT 0 ++ ++ ++/* ++ * 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); ++} ++ ++ ++ ++/********************************************* ++ * message layer ++ */ ++ ++/* ++ * entity_name ++ */ ++struct ceph_entity_name { ++ __le32 type; ++ __le32 num; ++} __attribute__ ((packed)); ++ ++#define CEPH_ENTITY_TYPE_MON 1 ++#define CEPH_ENTITY_TYPE_MDS 2 ++#define CEPH_ENTITY_TYPE_OSD 3 ++#define CEPH_ENTITY_TYPE_CLIENT 4 ++#define CEPH_ENTITY_TYPE_ADMIN 5 ++ ++/* used by message exchange protocol */ ++#define CEPH_MSGR_TAG_READY 1 /* server->client: ready for messages */ ++#define CEPH_MSGR_TAG_RESETSESSION 2 /* server->client: reset, try again */ ++#define CEPH_MSGR_TAG_WAIT 3 /* server->client: wait for racing ++ incoming connection */ ++#define CEPH_MSGR_TAG_RETRY_SESSION 4 /* server->client + cseq: try again ++ with higher cseq */ ++#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 */ ++ ++ ++/* ++ * entity_addr -- network address ++ */ ++struct ceph_entity_addr { ++ __le32 erank; /* entity's rank in process */ ++ __le32 nonce; /* unique id for process (e.g. pid) */ ++ struct sockaddr_in ipaddr; ++} __attribute__ ((packed)); ++ ++static inline bool ceph_entity_addr_is_local(const struct ceph_entity_addr *a, ++ const struct ceph_entity_addr *b) ++{ ++ return le32_to_cpu(a->nonce) == le32_to_cpu(b->nonce) && ++ a->ipaddr.sin_addr.s_addr == b->ipaddr.sin_addr.s_addr; ++} ++ ++static inline bool ceph_entity_addr_equal(const struct ceph_entity_addr *a, ++ const struct ceph_entity_addr *b) ++{ ++ return memcmp(a, b, sizeof(*a)) == 0; ++} ++ ++struct ceph_entity_inst { ++ struct ceph_entity_name name; ++ struct ceph_entity_addr addr; ++} __attribute__ ((packed)); ++ ++ ++/* ++ * connection negotiation ++ */ ++struct ceph_msg_connect { ++ __le32 host_type; /* CEPH_ENTITY_TYPE_* */ ++ __le32 global_seq; ++ __le32 connect_seq; ++ __u8 flags; ++} __attribute__ ((packed)); ++ ++struct ceph_msg_connect_reply { ++ __u8 tag; ++ __le32 global_seq; ++ __le32 connect_seq; ++ __u8 flags; ++} __attribute__ ((packed)); ++ ++#define CEPH_MSG_CONNECT_LOSSY 1 /* messages i send may be safely dropped */ ++ ++ ++/* ++ * message header ++ */ ++struct ceph_msg_header { ++ __le64 seq; /* message seq# for this session */ ++ __le16 type; /* message type */ ++ __le16 priority; /* priority. higher value == higher priority */ ++ __le16 mon_protocol, osd_protocol, mds_protocol, ++ client_protocol; /* protocol versions */ ++ __le32 front_len; /* bytes in main payload */ ++ __le32 data_off; /* sender: include full offset; ++ receiver: mask against ~PAGE_MASK */ ++ __le32 data_len; /* bytes of data payload */ ++ struct ceph_entity_inst src, orig_src, dst; ++ __le32 crc; /* header crc32c */ ++} __attribute__ ((packed)); ++ ++#define CEPH_MSG_PRIO_LOW 64 ++#define CEPH_MSG_PRIO_DEFAULT 127 ++#define CEPH_MSG_PRIO_HIGH 196 ++#define CEPH_MSG_PRIO_HIGHEST 255 ++ ++/* ++ * follows data payload ++ */ ++struct ceph_msg_footer { ++ __le32 flags; ++ __le32 front_crc; ++ __le32 data_crc; ++} __attribute__ ((packed)); ++ ++#define CEPH_MSG_FOOTER_ABORTED (1<<0) /* drop this message */ ++#define CEPH_MSG_FOOTER_NOCRC (1<<1) /* no data crc */ ++ ++ ++/* ++ * 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_UNMOUNT 11 ++#define CEPH_MSG_STATFS 12 ++#define CEPH_MSG_STATFS_REPLY 13 ++ ++/* 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 ++ ++/* 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_statfs { ++ struct ceph_fsid fsid; ++ __le64 tid; ++}; ++ ++struct ceph_statfs { ++ __le64 f_total; ++ __le64 f_free; /* used = total - free (KB) */ ++ __le64 f_avail; /* usable */ ++ __le64 f_objects; ++}; ++ ++struct ceph_mon_statfs_reply { ++ struct ceph_fsid fsid; ++ __le64 tid; ++ struct ceph_statfs st; ++}; ++ ++struct ceph_osd_getmap { ++ struct ceph_fsid fsid; ++ __le32 start; ++} __attribute__ ((packed)); ++ ++struct ceph_mds_getmap { ++ struct ceph_fsid fsid; ++ __le32 want; ++} __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_DESTROYING -2 /* down, existing, semi-destroyed. */ ++#define CEPH_MDS_STATE_FAILED 3 /* down, needs to be recovered. */ ++ ++#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_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_ACTIVE 12 /* up, active */ ++#define CEPH_MDS_STATE_STOPPING 13 /* up, but exporting metadata */ ++ ++ ++/* ++ * 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_IDIR 16 /* 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 */ ++ ++/* alias for either filelock or dirlock */ ++#define CEPH_LOCK_ICONTENT (CEPH_LOCK_IFILE|CEPH_LOCK_IDIR) ++ ++/* ++ * stat masks are defined in terms of the locks that cover inode fields. ++ */ ++#define CEPH_STAT_MASK_INODE CEPH_LOCK_INO ++#define CEPH_STAT_MASK_TYPE CEPH_LOCK_INO /* mode >> 12 */ ++#define CEPH_STAT_MASK_SYMLINK CEPH_LOCK_INO ++#define CEPH_STAT_MASK_UID CEPH_LOCK_IAUTH ++#define CEPH_STAT_MASK_GID CEPH_LOCK_IAUTH ++#define CEPH_STAT_MASK_MODE CEPH_LOCK_IAUTH ++#define CEPH_STAT_MASK_NLINK CEPH_LOCK_ILINK ++#define CEPH_STAT_MASK_LAYOUT CEPH_LOCK_ICONTENT ++#define CEPH_STAT_MASK_MTIME CEPH_LOCK_ICONTENT ++#define CEPH_STAT_MASK_SIZE CEPH_LOCK_ICONTENT ++#define CEPH_STAT_MASK_ATIME CEPH_LOCK_ICONTENT /* fixme */ ++#define CEPH_STAT_MASK_XATTR CEPH_LOCK_IXATTR ++#define CEPH_STAT_MASK_INODE_ALL (CEPH_LOCK_ICONTENT | CEPH_LOCK_IAUTH | \ ++ CEPH_LOCK_ILINK | CEPH_LOCK_INO) ++ ++/* 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, ++}; ++ ++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"; ++ default: return "???"; ++ } ++} ++ ++struct ceph_mds_session_head { ++ __le32 op; ++ __le64 seq; ++ struct ceph_timespec stamp; ++} __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 ++#define CEPH_MDS_OP_FOLLOW_LINK 0x010000 ++#define CEPH_MDS_OP_INO_PATH 0x100000 ++enum { ++ CEPH_MDS_OP_FINDINODE = 0x100100, ++ ++ CEPH_MDS_OP_LSTAT = 0x00100, ++ CEPH_MDS_OP_LUTIME = 0x01101, ++ CEPH_MDS_OP_LCHMOD = 0x01102, ++ CEPH_MDS_OP_LCHOWN = 0x01103, ++ CEPH_MDS_OP_LSETXATTR = 0x01104, ++ CEPH_MDS_OP_LRMXATTR = 0x01105, ++ CEPH_MDS_OP_LSETLAYOUT = 0x01106, ++ ++ CEPH_MDS_OP_STAT = 0x10100, ++ CEPH_MDS_OP_UTIME = 0x11101, ++ CEPH_MDS_OP_CHMOD = 0x11102, ++ CEPH_MDS_OP_CHOWN = 0x11103, ++ CEPH_MDS_OP_SETXATTR = 0x11104, ++ CEPH_MDS_OP_RMXATTR = 0x11105, ++ ++ 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_OPEN = 0x10302, ++ CEPH_MDS_OP_TRUNCATE = 0x11303, ++ CEPH_MDS_OP_LTRUNCATE = 0x01303, ++ CEPH_MDS_OP_FSYNC = 0x00304, ++ CEPH_MDS_OP_READDIR = 0x00305, ++ ++ CEPH_MDS_OP_MKSNAP = 0x01400, ++ CEPH_MDS_OP_RMSNAP = 0x01401, ++ CEPH_MDS_OP_LSSNAP = 0x00402, ++}; ++ ++static inline const char *ceph_mds_op_name(int op) ++{ ++ switch (op) { ++ case CEPH_MDS_OP_FINDINODE: return "findinode"; ++ case CEPH_MDS_OP_STAT: return "stat"; ++ case CEPH_MDS_OP_LSTAT: return "lstat"; ++ case CEPH_MDS_OP_UTIME: return "utime"; ++ case CEPH_MDS_OP_LUTIME: return "lutime"; ++ case CEPH_MDS_OP_CHMOD: return "chmod"; ++ case CEPH_MDS_OP_LCHMOD: return "lchmod"; ++ case CEPH_MDS_OP_CHOWN: return "chown"; ++ case CEPH_MDS_OP_LCHOWN: return "lchown"; ++ case CEPH_MDS_OP_LSETLAYOUT: return "lsetlayout"; ++ case CEPH_MDS_OP_SETXATTR: return "setxattr"; ++ case CEPH_MDS_OP_LSETXATTR: return "lsetxattr"; ++ case CEPH_MDS_OP_RMXATTR: return "rmxattr"; ++ case CEPH_MDS_OP_LRMXATTR: return "lrmxattr"; ++ 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_OPEN: return "open"; ++ case CEPH_MDS_OP_TRUNCATE: return "truncate"; ++ case CEPH_MDS_OP_LTRUNCATE: return "ltruncate"; ++ case CEPH_MDS_OP_FSYNC: return "fsync"; ++ case CEPH_MDS_OP_LSSNAP: return "lssnap"; ++ case CEPH_MDS_OP_MKSNAP: return "mksnap"; ++ case CEPH_MDS_OP_RMSNAP: return "rmsnap"; ++ default: return "???"; ++ } ++} ++ ++struct ceph_mds_request_head { ++ ceph_tid_t tid, oldest_client_tid; ++ ceph_epoch_t mdsmap_epoch; /* on client */ ++ __le32 num_fwd; ++ __le32 retry_attempt; ++ __le64 mds_wants_replica_in_dirino; ++ __le32 op; ++ __le32 caller_uid, caller_gid; ++ ++ union { ++ struct { ++ __le32 mask; ++ } __attribute__ ((packed)) stat; ++ struct { ++ __le32 mask; ++ } __attribute__ ((packed)) fstat; ++ struct { ++ __le32 frag; ++ } __attribute__ ((packed)) readdir; ++ struct { ++ struct ceph_timespec mtime; ++ struct ceph_timespec atime; ++ struct ceph_timespec ctime; ++ __le32 mask; ++ } __attribute__ ((packed)) utime; ++ struct { ++ __le32 mode; ++ } __attribute__ ((packed)) chmod; ++ struct { ++ __le32 uid; ++ __le32 gid; ++ __le32 mask; ++ } __attribute__ ((packed)) chown; ++ struct { ++ __le32 mode; ++ __le32 rdev; ++ } __attribute__ ((packed)) mknod; ++ struct { ++ __le32 mode; ++ } __attribute__ ((packed)) mkdir; ++ struct { ++ __le32 flags; ++ __le32 mode; ++ } __attribute__ ((packed)) open; ++ struct { ++ __le64 length; ++ } __attribute__ ((packed)) truncate; ++ struct { ++ __le32 flags; ++ } __attribute__ ((packed)) setxattr; ++ struct { ++ struct ceph_file_layout layout; ++ } __attribute__ ((packed)) setlayout; ++ } __attribute__ ((packed)) args; ++} __attribute__ ((packed)); ++ ++/* masks for utimes() */ ++#define CEPH_UTIME_ATIME 1 ++#define CEPH_UTIME_MTIME 2 ++#define CEPH_UTIME_CTIME 4 ++ ++/* masks for chown */ ++#define CEPH_CHOWN_UID 1 ++#define CEPH_CHOWN_GID 2 ++ ++struct ceph_inopath_item { ++ __le64 ino; ++ __le32 dname_hash; ++} __attribute__ ((packed)); ++ ++/* client reply */ ++struct ceph_mds_reply_head { ++ ceph_tid_t tid; ++ __le32 op; ++ __le32 result; ++ __le32 file_caps; ++ __le32 file_caps_seq; ++ __le32 file_caps_mseq; ++ __le32 mdsmap_epoch; ++} __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; ++ struct ceph_frag_tree_split splits[]; ++} __attribute__ ((packed)); ++ ++struct ceph_mds_reply_inode { ++ __le64 ino; ++ __le64 snapid; ++ __le64 version; ++ struct ceph_file_layout layout; ++ struct ceph_timespec ctime, mtime, atime; ++ __le64 time_warp_seq; ++ __le32 rdev; ++ __le32 mode, uid, gid; ++ __le32 nlink; ++ __le64 size, max_size, truncate_seq; ++ __le64 files, subdirs, rbytes, rfiles, rsubdirs; /* dir stats */ ++ struct ceph_timespec rctime; ++ struct ceph_frag_tree_head fragtree; ++} __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; ++} __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 */ ++ ++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; ++} ++ ++/* client file caps */ ++#define CEPH_CAP_PIN 1 /* no specific capabilities beyond the pin */ ++#define CEPH_CAP_RDCACHE 2 /* client can cache reads */ ++#define CEPH_CAP_RD 4 /* client can read */ ++#define CEPH_CAP_WR 8 /* client can write */ ++#define CEPH_CAP_WRBUFFER 16 /* client can buffer writes */ ++#define CEPH_CAP_WREXTEND 32 /* client can extend EOF */ ++#define CEPH_CAP_LAZYIO 64 /* client can perform lazy io */ ++#define CEPH_CAP_EXCL 128 /* exclusive/loner access */ ++ ++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_RD | CEPH_CAP_RDCACHE; ++ case CEPH_FILE_MODE_RDWR: ++ return CEPH_CAP_PIN | ++ CEPH_CAP_RD | CEPH_CAP_RDCACHE | ++ CEPH_CAP_WR | CEPH_CAP_WRBUFFER | ++ CEPH_CAP_EXCL; ++ case CEPH_FILE_MODE_WR: ++ return CEPH_CAP_PIN | ++ CEPH_CAP_WR | CEPH_CAP_WRBUFFER | ++ CEPH_CAP_EXCL; ++ } ++ return 0; ++} ++ ++enum { ++ CEPH_CAP_OP_GRANT, /* mds->client grant */ ++ 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_RELEASED, /* mds->client close out cap */ ++ CEPH_CAP_OP_FLUSHEDSNAP, /* mds->client flushed snap */ ++ CEPH_CAP_OP_ACK, /* client->mds ack (if prior grant was recall) */ ++ CEPH_CAP_OP_REQUEST, /* client->mds request (update wanted bits) */ ++ CEPH_CAP_OP_FLUSHSNAP, /* client->mds flush snapped metadata */ ++ CEPH_CAP_OP_RELEASE, /* client->mds request release cap */ ++}; ++ ++static inline const char *ceph_cap_op_name(int op) ++{ ++ switch (op) { ++ case CEPH_CAP_OP_GRANT: return "grant"; ++ 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_RELEASED: return "released"; ++ case CEPH_CAP_OP_FLUSHEDSNAP: return "flushedsnap"; ++ case CEPH_CAP_OP_ACK: return "ack"; ++ case CEPH_CAP_OP_REQUEST: return "request"; ++ case CEPH_CAP_OP_FLUSHSNAP: return "flushsnap"; ++ case CEPH_CAP_OP_RELEASE: return "release"; ++ default: return "???"; ++ } ++} ++ ++/* ++ * caps message, used for capability callbacks, acks, requests, etc. ++ */ ++struct ceph_mds_caps { ++ __le32 op; ++ __le64 ino; ++ __le32 seq; ++ __le32 caps, wanted; ++ __le64 size, max_size; ++ __le64 truncate_seq; ++ __le32 migrate_seq; ++ struct ceph_timespec mtime, atime, ctime; ++ struct ceph_file_layout layout; ++ __le64 time_warp_seq; ++ __le64 snap_follows; ++ __le32 snap_trace_len; ++} __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 */ ++ ++struct ceph_mds_lease { ++ __u8 action; ++ __le16 mask; ++ __le64 ino; ++ __le64 first, last; ++} __attribute__ ((packed)); ++/* followed by a __le32+string for dname */ ++ ++ ++/* client reconnect */ ++struct ceph_mds_cap_reconnect { ++ __le32 wanted; ++ __le32 issued; ++ __le64 size; ++ struct ceph_timespec mtime, atime; ++ __le64 snaprealm; ++} __attribute__ ((packed)); ++/* followed by encoded string */ ++ ++struct ceph_mds_snaprealm_reconnect { ++ __le64 ino; ++ __le64 seq; ++ __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, ++}; ++ ++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 "???"; ++ } ++} ++ ++struct ceph_mds_snap_head { ++ __le32 op; ++ __le64 split; ++ __le32 num_split_inos; ++ __le32 num_split_realms; ++ __le32 trace_len; ++} __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 */ ++ ++/* ++ * osd map flag bits ++ */ ++#define CEPH_OSDMAP_NEARFULL (1<<0) /* sync writes (near ENOSPC) */ ++#define CEPH_OSDMAP_FULL (1<<1) /* no data writes (ENOSPC) */ ++ ++/* ++ * osd ops ++ */ ++#define CEPH_OSD_OP_MODE 0xf000 ++#define CEPH_OSD_OP_MODE_RD 0x1000 ++#define CEPH_OSD_OP_MODE_WR 0x2000 ++#define CEPH_OSD_OP_MODE_SUB 0x4000 ++ ++#define CEPH_OSD_OP_TYPE 0x0f00 ++#define CEPH_OSD_OP_TYPE_LOCK 0x0100 ++#define CEPH_OSD_OP_TYPE_DATA 0x0200 ++#define CEPH_OSD_OP_TYPE_ATTR 0x0300 ++ ++enum { ++ /* read */ ++ CEPH_OSD_OP_READ = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_DATA | 1, ++ CEPH_OSD_OP_STAT = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_DATA | 2, ++ ++ CEPH_OSD_OP_GETXATTR = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_ATTR | 1, ++ CEPH_OSD_OP_GETXATTRS = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_ATTR | 2, ++ ++ /* subop */ ++ CEPH_OSD_OP_PULL = CEPH_OSD_OP_MODE_SUB | 1, ++ CEPH_OSD_OP_PUSH = CEPH_OSD_OP_MODE_SUB | 2, ++ CEPH_OSD_OP_BALANCEREADS = CEPH_OSD_OP_MODE_SUB | 3, ++ CEPH_OSD_OP_UNBALANCEREADS = CEPH_OSD_OP_MODE_SUB | 4, ++ ++ /* object data */ ++ CEPH_OSD_OP_WRITE = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 1, ++ CEPH_OSD_OP_WRITEFULL = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 2, ++ CEPH_OSD_OP_TRUNCATE = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 3, ++ CEPH_OSD_OP_ZERO = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 4, ++ CEPH_OSD_OP_DELETE = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 5, ++ ++ /* object attrs */ ++ CEPH_OSD_OP_SETXATTR = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_ATTR | 1, ++ CEPH_OSD_OP_SETXATTRS = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_ATTR | 2, ++ CEPH_OSD_OP_RESETXATTRS= CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_ATTR | 3, ++ CEPH_OSD_OP_RMXATTR = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_ATTR | 4, ++ ++ /* lock */ ++ CEPH_OSD_OP_WRLOCK = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_LOCK | 1, ++ CEPH_OSD_OP_WRUNLOCK = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_LOCK | 2, ++ CEPH_OSD_OP_RDLOCK = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_LOCK | 3, ++ CEPH_OSD_OP_RDUNLOCK = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_LOCK | 4, ++ CEPH_OSD_OP_UPLOCK = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_LOCK | 5, ++ CEPH_OSD_OP_DNLOCK = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_LOCK | 6, ++ ++ /* fancy read */ ++ CEPH_OSD_OP_GREP = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_DATA | 3, ++ ++ /* fancy write */ ++ CEPH_OSD_OP_APPEND = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 6, ++}; ++ ++static inline int ceph_osd_op_type_lock(int op) ++{ ++ return (op & CEPH_OSD_OP_TYPE) == CEPH_OSD_OP_TYPE_LOCK; ++} ++static inline int ceph_osd_op_type_data(int op) ++{ ++ return (op & CEPH_OSD_OP_TYPE) == CEPH_OSD_OP_TYPE_DATA; ++} ++static inline int ceph_osd_op_type_attr(int op) ++{ ++ return (op & CEPH_OSD_OP_TYPE) == CEPH_OSD_OP_TYPE_ATTR; ++} ++ ++static inline int ceph_osd_op_mode_subop(int op) ++{ ++ return (op & CEPH_OSD_OP_MODE) == CEPH_OSD_OP_MODE_SUB; ++} ++static inline int ceph_osd_op_mode_read(int op) ++{ ++ return (op & CEPH_OSD_OP_MODE) == CEPH_OSD_OP_MODE_RD; ++} ++static inline int ceph_osd_op_mode_modify(int op) ++{ ++ return (op & CEPH_OSD_OP_MODE) == CEPH_OSD_OP_MODE_WR; ++} ++ ++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_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_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_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_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"; ++ ++ default: return "???"; ++ } ++} ++ ++ ++/* ++ * osd op flags ++ */ ++enum { ++ CEPH_OSD_OP_ACK = 1, /* want (or is) "ack" ack */ ++ CEPH_OSD_OP_SAFE = 2, /* want (or is) "safe" ack */ ++ CEPH_OSD_OP_RETRY = 4, /* resend attempt */ ++ CEPH_OSD_OP_INCLOCK_FAIL = 8, /* fail on inclock collision */ ++ CEPH_OSD_OP_MODIFY = 16, /* op is/was a mutation */ ++ CEPH_OSD_OP_ACKNVRAM = 32, /* ACK when stable in NVRAM, not RAM */ ++ CEPH_OSD_OP_ORDERSNAP = 64, /* EOLDSNAP if snapc is out of order */ ++ CEPH_OSD_OP_PEERSTAT = 128, /* msg includes osd_peer_stat */ ++ CEPH_OSD_OP_BALANCE_READS = 256, ++}; ++ ++#define EOLDSNAPC 44 /* ORDERSNAP flag set and writer has old snap context*/ ++ ++struct ceph_osd_op { ++ __le16 op; ++ union { ++ struct { ++ __le64 offset, length; ++ }; ++ struct { ++ __le32 name_len; ++ __le32 value_len; ++ }; ++ }; ++} __attribute__ ((packed)); ++ ++struct ceph_osd_request_head { ++ ceph_tid_t tid; ++ __le32 client_inc; ++ struct ceph_object oid; ++ struct ceph_object_layout layout; ++ ceph_epoch_t osdmap_epoch; ++ ++ __le32 flags; ++ __le32 inc_lock; ++ ++ struct ceph_eversion reassert_version; ++ ++ /* writer's snap context */ ++ __le64 snap_seq; ++ __le32 num_snaps; ++ ++ /* read or mutation */ ++ __le16 num_ops; ++ __u16 object_type; ++ struct ceph_osd_op ops[]; /* followed by snaps */ ++} __attribute__ ((packed)); ++ ++struct ceph_osd_reply_head { ++ ceph_tid_t tid; ++ __le32 flags; ++ struct ceph_object oid; ++ struct ceph_object_layout layout; ++ ceph_epoch_t osdmap_epoch; ++ struct ceph_eversion reassert_version; ++ ++ __le32 result; ++ ++ __le32 num_ops; ++ struct ceph_osd_op ops[0]; ++} __attribute__ ((packed)); ++ ++#endif +Index: plugins/Makefile.am +=================================================================== +--- plugins/Makefile.am (revision 26845) ++++ plugins/Makefile.am (working copy) +@@ -26,6 +26,7 @@ + agentx \ + artnet \ + asn1 \ ++ ceph \ + ciscosm \ + docsis \ + enttec \ +Index: epan/Makefile.am +=================================================================== +--- epan/Makefile.am (revision 26845) ++++ epan/Makefile.am (working copy) +@@ -189,6 +189,7 @@ + plugin_src = \ + ../plugins/artnet/packet-artnet.c \ + ../plugins/asn1/packet-asn1.c \ ++ ../plugins/ceph/packet-ceph.c \ + ../plugins/docsis/packet-bpkmattr.c \ + ../plugins/docsis/packet-bpkmreq.c \ + ../plugins/docsis/packet-bpkmrsp.c \ +Index: packaging/nsis/Makefile.nmake +=================================================================== +--- packaging/nsis/Makefile.nmake (revision 26845) ++++ packaging/nsis/Makefile.nmake (working copy) +@@ -47,6 +47,7 @@ + ../../plugins/agentx/agentx.dll \ + ../../plugins/artnet/artnet.dll \ + ../../plugins/asn1/asn1.dll \ ++ ../../plugins/ceph/ceph.dll \ + ../../plugins/ciscosm/ciscosm.dll \ + ../../plugins/docsis/docsis.dll \ + ../../plugins/enttec/enttec.dll \ +Index: packaging/nsis/wireshark.nsi +=================================================================== +--- packaging/nsis/wireshark.nsi (revision 26845) ++++ packaging/nsis/wireshark.nsi (working copy) +@@ -779,6 +779,7 @@ + File "..\..\plugins\agentx\agentx.dll" + File "..\..\plugins\artnet\artnet.dll" + File "..\..\plugins\asn1\asn1.dll" ++File "..\..\plugins\ceph\ceph.dll" + File "..\..\plugins\ciscosm\ciscosm.dll" + File "..\..\plugins\docsis\docsis.dll" + File "..\..\plugins\enttec\enttec.dll" |