Converted scsi dissectors display filter format from scsi.<protocol> to scsi_<protocol> (matching their registered filter name)

git-svn-id: http://anonsvn.wireshark.org/wireshark/trunk@43993 f5534014-38df-0310-8fa8-9805f1628bb7

1 files changed, 81 insertions, 81 deletions

diff --git a/epan/dissectors/packet-scsi-osd.c b/epan/dissectors/packet-scsi-osd.c
index d4de87aade..f5978682e2 100644
--- a/epan/dissectors/packet-scsi-osd.c
+++ b/epan/dissectors/packet-scsi-osd.c
@@ -2950,253 +2950,253 @@ proto_register_scsi_osd(void)
 {
 	static hf_register_info hf[] = {
         { &hf_scsi_osd_opcode,
-          {"OSD Opcode", "scsi.osd.opcode", FT_UINT8, BASE_HEX,
+          {"OSD Opcode", "scsi_osd.opcode", FT_UINT8, BASE_HEX,
            VALS (scsi_osd_vals), 0x0, NULL, HFILL}},
         { &hf_scsi_osd_add_cdblen,
-          {"Additional CDB Length", "scsi.osd.addcdblen", FT_UINT8, BASE_DEC,
+          {"Additional CDB Length", "scsi_osd.addcdblen", FT_UINT8, BASE_DEC,
            NULL, 0x0, NULL, HFILL}},
         { &hf_scsi_osd_svcaction,
-          {"Service Action", "scsi.osd.svcaction", FT_UINT16, BASE_HEX,
+          {"Service Action", "scsi_osd.svcaction", FT_UINT16, BASE_HEX,
            VALS(scsi_osd_svcaction_vals), 0x0, NULL, HFILL}},
         { &hf_scsi_osd_option,
-          {"Options Byte", "scsi.osd.option", FT_UINT8, BASE_HEX,
+          {"Options Byte", "scsi_osd.option", FT_UINT8, BASE_HEX,
            NULL, 0x0, NULL, HFILL}},
         { &hf_scsi_osd_option_dpo,
-          {"DPO", "scsi.osd.option.dpo", FT_BOOLEAN, 8,
+          {"DPO", "scsi_osd.option.dpo", FT_BOOLEAN, 8,
            TFS(&option_dpo_tfs), 0x10, NULL, HFILL}},
         { &hf_scsi_osd_option_fua,
-          {"FUA", "scsi.osd.option.fua", FT_BOOLEAN, 8,
+          {"FUA", "scsi_osd.option.fua", FT_BOOLEAN, 8,
            TFS(&option_fua_tfs), 0x08, NULL, HFILL}},
         { &hf_scsi_osd_getsetattrib,
-          {"GET/SET CDBFMT", "scsi.osd.getset", FT_UINT8, BASE_HEX,
+          {"GET/SET CDBFMT", "scsi_osd.getset", FT_UINT8, BASE_HEX,
            VALS(scsi_osd_getsetattrib_vals), 0x30, NULL, HFILL}},
         { &hf_scsi_osd_timestamps_control,
-          {"Timestamps Control", "scsi.osd.timestamps_control", FT_UINT8, BASE_HEX,
+          {"Timestamps Control", "scsi_osd.timestamps_control", FT_UINT8, BASE_HEX,
            VALS(scsi_osd_timestamps_control_vals), 0x0, NULL, HFILL}},
         { &hf_scsi_osd_formatted_capacity,
-          {"Formatted Capacity", "scsi.osd.formatted_capacity", FT_UINT64, BASE_DEC,
+          {"Formatted Capacity", "scsi_osd.formatted_capacity", FT_UINT64, BASE_DEC,
            NULL, 0x0, NULL, HFILL}},
         { &hf_scsi_osd_get_attributes_page,
-          {"Get Attributes Page", "scsi.osd.get_attributes_page", FT_UINT32, BASE_HEX,
+          {"Get Attributes Page", "scsi_osd.get_attributes_page", FT_UINT32, BASE_HEX,
            NULL, 0x0, NULL, HFILL}},
         { &hf_scsi_osd_get_attributes_list_length,
-          {"Get Attributes List Length", "scsi.osd.get_attributes_list_length", FT_UINT32, BASE_HEX,
+          {"Get Attributes List Length", "scsi_osd.get_attributes_list_length", FT_UINT32, BASE_HEX,
            NULL, 0x0, NULL, HFILL}},
         { &hf_scsi_osd_get_attributes_list_offset,
-          {"Get Attributes List Offset", "scsi.osd.get_attributes_list_offset", FT_UINT32, BASE_HEX,
+          {"Get Attributes List Offset", "scsi_osd.get_attributes_list_offset", FT_UINT32, BASE_HEX,
            NULL, 0x0, NULL, HFILL}},
         { &hf_scsi_osd_set_attributes_list_length,
-          {"Set Attributes List Length", "scsi.osd.set_attributes_list_length", FT_UINT32, BASE_HEX,
+          {"Set Attributes List Length", "scsi_osd.set_attributes_list_length", FT_UINT32, BASE_HEX,
            NULL, 0x0, NULL, HFILL}},
         { &hf_scsi_osd_set_attributes_list_offset,
-          {"Set Attributes List Offset", "scsi.osd.set_attributes_list_offset", FT_UINT32, BASE_HEX,
+          {"Set Attributes List Offset", "scsi_osd.set_attributes_list_offset", FT_UINT32, BASE_HEX,
            NULL, 0x0, NULL, HFILL}},
         { &hf_scsi_osd_get_attributes_allocation_length,
-          {"Get Attributes Allocation Length", "scsi.osd.get_attributes_allocation_length", FT_UINT32, BASE_HEX,
+          {"Get Attributes Allocation Length", "scsi_osd.get_attributes_allocation_length", FT_UINT32, BASE_HEX,
            NULL, 0x0, NULL, HFILL}},
         { &hf_scsi_osd_retrieved_attributes_offset,
-          {"Retrieved Attributes Offset", "scsi.osd.retrieved_attributes_offset", FT_UINT32, BASE_HEX,
+          {"Retrieved Attributes Offset", "scsi_osd.retrieved_attributes_offset", FT_UINT32, BASE_HEX,
            NULL, 0x0, NULL, HFILL}},
         { &hf_scsi_osd_set_attributes_page,
-          {"Set Attributes Page", "scsi.osd.set_attributes_page", FT_UINT32, BASE_HEX,
+          {"Set Attributes Page", "scsi_osd.set_attributes_page", FT_UINT32, BASE_HEX,
            NULL, 0x0, NULL, HFILL}},
         { &hf_scsi_osd_set_attribute_length,
-          {"Set Attribute Length", "scsi.osd.set_attribute_length", FT_UINT32, BASE_HEX,
+          {"Set Attribute Length", "scsi_osd.set_attribute_length", FT_UINT32, BASE_HEX,
            NULL, 0x0, NULL, HFILL}},
         { &hf_scsi_osd_set_attribute_number,
-          {"Set Attribute Number", "scsi.osd.set_attribute_number", FT_UINT32, BASE_HEX,
+          {"Set Attribute Number", "scsi_osd.set_attribute_number", FT_UINT32, BASE_HEX,
            NULL, 0x0, NULL, HFILL}},
         { &hf_scsi_osd_set_attributes_offset,
-          {"Set Attributes Offset", "scsi.osd.set_attributes_offset", FT_UINT32, BASE_HEX,
+          {"Set Attributes Offset", "scsi_osd.set_attributes_offset", FT_UINT32, BASE_HEX,
            NULL, 0x0, NULL, HFILL}},
         { &hf_scsi_osd_capability_format,
-          {"Capability Format", "scsi.osd.capability_format", FT_UINT8, BASE_HEX,
+          {"Capability Format", "scsi_osd.capability_format", FT_UINT8, BASE_HEX,
            VALS(scsi_osd_capability_format_vals), 0x0f, NULL, HFILL}},
         { &hf_scsi_osd_key_version,
-          {"Key Version", "scsi.osd.key_version", FT_UINT8, BASE_HEX,
+          {"Key Version", "scsi_osd.key_version", FT_UINT8, BASE_HEX,
            NULL, 0xf0, NULL, HFILL}},
         { &hf_scsi_osd_icva,
-          {"Integrity Check Value Algorithm", "scsi.osd.icva", FT_UINT8, BASE_HEX,
+          {"Integrity Check Value Algorithm", "scsi_osd.icva", FT_UINT8, BASE_HEX,
            NULL, 0x0f, NULL, HFILL}},
         { &hf_scsi_osd_security_method,
-          {"Security Method", "scsi.osd.security_method", FT_UINT8, BASE_HEX,
+          {"Security Method", "scsi_osd.security_method", FT_UINT8, BASE_HEX,
            NULL, 0x0f, NULL, HFILL}},
         { &hf_scsi_osd_capability_expiration_time,
-          {"Capability Expiration Time", "scsi.osd.capability_expiration_time", FT_BYTES, BASE_NONE,
+          {"Capability Expiration Time", "scsi_osd.capability_expiration_time", FT_BYTES, BASE_NONE,
            NULL, 0, NULL, HFILL}},
         { &hf_scsi_osd_audit,
-          {"Audit", "scsi.osd.audit", FT_BYTES, BASE_NONE,
+          {"Audit", "scsi_osd.audit", FT_BYTES, BASE_NONE,
            NULL, 0, NULL, HFILL}},
         { &hf_scsi_osd_capability_discriminator,
-          {"Capability Discriminator", "scsi.osd.capability_descriminator", FT_BYTES, BASE_NONE,
+          {"Capability Discriminator", "scsi_osd.capability_descriminator", FT_BYTES, BASE_NONE,
            NULL, 0, NULL, HFILL}},
         { &hf_scsi_osd_object_created_time,
-          {"Object Created Time", "scsi.osd.object_created_time", FT_BYTES, BASE_NONE,
+          {"Object Created Time", "scsi_osd.object_created_time", FT_BYTES, BASE_NONE,
            NULL, 0, NULL, HFILL}},
         { &hf_scsi_osd_object_type,
-          {"Object Type", "scsi.osd.object_type", FT_UINT8, BASE_HEX,
+          {"Object Type", "scsi_osd.object_type", FT_UINT8, BASE_HEX,
            VALS(scsi_osd_object_type_vals), 0, NULL, HFILL}},
         { &hf_scsi_osd_permissions,
-          {"Permissions", "scsi.osd.permissions", FT_UINT16, BASE_HEX,
+          {"Permissions", "scsi_osd.permissions", FT_UINT16, BASE_HEX,
            NULL, 0, NULL, HFILL}},
         { &hf_scsi_osd_permissions_read,
-          {"READ", "scsi.osd.permissions.read", FT_BOOLEAN, 16,
+          {"READ", "scsi_osd.permissions.read", FT_BOOLEAN, 16,
            TFS(&permissions_read_tfs), 0x8000, NULL, HFILL}},
         { &hf_scsi_osd_permissions_write,
-          {"WRITE", "scsi.osd.permissions.write", FT_BOOLEAN, 16,
+          {"WRITE", "scsi_osd.permissions.write", FT_BOOLEAN, 16,
            TFS(&permissions_write_tfs), 0x4000, NULL, HFILL}},
         { &hf_scsi_osd_permissions_get_attr,
-          {"GET_ATTR", "scsi.osd.permissions.get_attr", FT_BOOLEAN, 16,
+          {"GET_ATTR", "scsi_osd.permissions.get_attr", FT_BOOLEAN, 16,
            TFS(&permissions_get_attr_tfs), 0x2000, NULL, HFILL}},
         { &hf_scsi_osd_permissions_set_attr,
-          {"SET_ATTR", "scsi.osd.permissions.set_attr", FT_BOOLEAN, 16,
+          {"SET_ATTR", "scsi_osd.permissions.set_attr", FT_BOOLEAN, 16,
            TFS(&permissions_set_attr_tfs), 0x1000, NULL, HFILL}},
         { &hf_scsi_osd_permissions_create,
-          {"CREATE", "scsi.osd.permissions.create", FT_BOOLEAN, 16,
+          {"CREATE", "scsi_osd.permissions.create", FT_BOOLEAN, 16,
            TFS(&permissions_create_tfs), 0x0800, NULL, HFILL}},
         { &hf_scsi_osd_permissions_remove,
-          {"REMOVE", "scsi.osd.permissions.remove", FT_BOOLEAN, 16,
+          {"REMOVE", "scsi_osd.permissions.remove", FT_BOOLEAN, 16,
            TFS(&permissions_remove_tfs), 0x0400, NULL, HFILL}},
         { &hf_scsi_osd_permissions_obj_mgmt,
-          {"OBJ_MGMT", "scsi.osd.permissions.obj_mgmt", FT_BOOLEAN, 16,
+          {"OBJ_MGMT", "scsi_osd.permissions.obj_mgmt", FT_BOOLEAN, 16,
            TFS(&permissions_obj_mgmt_tfs), 0x0200, NULL, HFILL}},
         { &hf_scsi_osd_permissions_append,
-          {"APPEND", "scsi.osd.permissions.append", FT_BOOLEAN, 16,
+          {"APPEND", "scsi_osd.permissions.append", FT_BOOLEAN, 16,
            TFS(&permissions_append_tfs), 0x0100, NULL, HFILL}},
         { &hf_scsi_osd_permissions_dev_mgmt,
-          {"DEV_MGMT", "scsi.osd.permissions.dev_mgmt", FT_BOOLEAN, 16,
+          {"DEV_MGMT", "scsi_osd.permissions.dev_mgmt", FT_BOOLEAN, 16,
            TFS(&permissions_dev_mgmt_tfs), 0x0080, NULL, HFILL}},
         { &hf_scsi_osd_permissions_global,
-          {"GLOBAL", "scsi.osd.permissions.global", FT_BOOLEAN, 16,
+          {"GLOBAL", "scsi_osd.permissions.global", FT_BOOLEAN, 16,
            TFS(&permissions_global_tfs), 0x0040, NULL, HFILL}},
         { &hf_scsi_osd_permissions_pol_sec,
-          {"POL/SEC", "scsi.osd.permissions.pol_sec", FT_BOOLEAN, 16,
+          {"POL/SEC", "scsi_osd.permissions.pol_sec", FT_BOOLEAN, 16,
            TFS(&permissions_pol_sec_tfs), 0x0020, NULL, HFILL}},
 
         { &hf_scsi_osd_object_descriptor_type,
-          {"Object Descriptor Type", "scsi.osd.object_descriptor_type", FT_UINT8, BASE_HEX,
+          {"Object Descriptor Type", "scsi_osd.object_descriptor_type", FT_UINT8, BASE_HEX,
            VALS(scsi_osd_object_descriptor_type_vals), 0xf0, NULL, HFILL}},
         { &hf_scsi_osd_object_descriptor,
-          {"Object Descriptor", "scsi.osd.object_descriptor", FT_BYTES, BASE_NONE,
+          {"Object Descriptor", "scsi_osd.object_descriptor", FT_BYTES, BASE_NONE,
            NULL, 0, NULL, HFILL}},
         { &hf_scsi_osd_ricv,
-          {"Request Integrity Check value", "scsi.osd.ricv", FT_BYTES, BASE_NONE,
+          {"Request Integrity Check value", "scsi_osd.ricv", FT_BYTES, BASE_NONE,
            NULL, 0, NULL, HFILL}},
         { &hf_scsi_osd_request_nonce,
-          {"Request Nonce", "scsi.osd.request_nonce", FT_BYTES, BASE_NONE,
+          {"Request Nonce", "scsi_osd.request_nonce", FT_BYTES, BASE_NONE,
            NULL, 0, NULL, HFILL}},
         { &hf_scsi_osd_diicvo,
-          {"Data-In Integrity Check Value Offset", "scsi.osd.diicvo", FT_UINT32, BASE_DEC,
+          {"Data-In Integrity Check Value Offset", "scsi_osd.diicvo", FT_UINT32, BASE_DEC,
            NULL, 0, NULL, HFILL}},
         { &hf_scsi_osd_doicvo,
-          {"Data-Out Integrity Check Value Offset", "scsi.osd.doicvo", FT_UINT32, BASE_DEC,
+          {"Data-Out Integrity Check Value Offset", "scsi_osd.doicvo", FT_UINT32, BASE_DEC,
            NULL, 0, NULL, HFILL}},
         { &hf_scsi_osd_requested_partition_id,
-          {"Requested Partition Id", "scsi.osd.requested_partition_id", FT_UINT64, BASE_HEX,
+          {"Requested Partition Id", "scsi_osd.requested_partition_id", FT_UINT64, BASE_HEX,
            NULL, 0, NULL, HFILL}},
         { &hf_scsi_osd_sortorder,
-          {"Sort Order", "scsi.osd.sort_order", FT_UINT8, BASE_DEC,
+          {"Sort Order", "scsi_osd.sort_order", FT_UINT8, BASE_DEC,
            VALS(scsi_osd_sort_order_vals), 0x0f, NULL, HFILL}},
         { &hf_scsi_osd_partition_id,
-          {"Partition Id", "scsi.osd.partition_id", FT_UINT64, BASE_HEX,
+          {"Partition Id", "scsi_osd.partition_id", FT_UINT64, BASE_HEX,
            NULL, 0, NULL, HFILL}},
         { &hf_scsi_osd_list_identifier,
-          {"List Identifier", "scsi.osd.list_identifier", FT_UINT32, BASE_DEC,
+          {"List Identifier", "scsi_osd.list_identifier", FT_UINT32, BASE_DEC,
            NULL, 0, NULL, HFILL}},
         { &hf_scsi_osd_allocation_length,
-          {"Allocation Length", "scsi.osd.allocation_length", FT_UINT64, BASE_DEC,
+          {"Allocation Length", "scsi_osd.allocation_length", FT_UINT64, BASE_DEC,
            NULL, 0, NULL, HFILL}},
         { &hf_scsi_osd_length,
-          {"Length", "scsi.osd.length", FT_UINT64, BASE_DEC,
+          {"Length", "scsi_osd.length", FT_UINT64, BASE_DEC,
            NULL, 0, NULL, HFILL}},
         { &hf_scsi_osd_starting_byte_address,
-          {"Starting Byte Address", "scsi.osd.starting_byte_address", FT_UINT64, BASE_DEC,
+          {"Starting Byte Address", "scsi_osd.starting_byte_address", FT_UINT64, BASE_DEC,
            NULL, 0, NULL, HFILL}},
         { &hf_scsi_osd_initial_object_id,
-          {"Initial Object Id", "scsi.osd.initial_object_id", FT_BYTES, BASE_NONE,
+          {"Initial Object Id", "scsi_osd.initial_object_id", FT_BYTES, BASE_NONE,
            NULL, 0, NULL, HFILL}},
 	{ &hf_scsi_osd_additional_length,
-          {"Additional Length", "scsi.osd.additional_length", FT_UINT64, BASE_DEC,
+          {"Additional Length", "scsi_osd.additional_length", FT_UINT64, BASE_DEC,
            NULL, 0, NULL, HFILL}},
         { &hf_scsi_osd_continuation_object_id,
-          {"Continuation Object Id", "scsi.osd.continuation_object_id", FT_BYTES, BASE_NONE,
+          {"Continuation Object Id", "scsi_osd.continuation_object_id", FT_BYTES, BASE_NONE,
            NULL, 0, NULL, HFILL}},
         { &hf_scsi_osd_user_object_id,
-          {"User Object Id", "scsi.osd.user_object_id", FT_BYTES, BASE_NONE,
+          {"User Object Id", "scsi_osd.user_object_id", FT_BYTES, BASE_NONE,
            NULL, 0, NULL, HFILL}},
         { &hf_scsi_osd_list_flags_lstchg,
-          {"LSTCHG", "scsi.osd.list.lstchg", FT_BOOLEAN, 8,
+          {"LSTCHG", "scsi_osd.list.lstchg", FT_BOOLEAN, 8,
            TFS(&list_lstchg_tfs), 0x02, NULL, HFILL}},
         { &hf_scsi_osd_list_flags_root,
-          {"ROOT", "scsi.osd.list.root", FT_BOOLEAN, 8,
+          {"ROOT", "scsi_osd.list.root", FT_BOOLEAN, 8,
            TFS(&list_root_tfs), 0x01, NULL, HFILL}},
         { &hf_scsi_osd_requested_user_object_id,
-          {"Requested User Object Id", "scsi.osd.requested_user_object_id", FT_BYTES, BASE_NONE,
+          {"Requested User Object Id", "scsi_osd.requested_user_object_id", FT_BYTES, BASE_NONE,
            NULL, 0, NULL, HFILL}},
 	{ &hf_scsi_osd_number_of_user_objects,
-          {"Number Of User Objects", "scsi.osd.number_of_user_objects", FT_UINT16, BASE_DEC,
+          {"Number Of User Objects", "scsi_osd.number_of_user_objects", FT_UINT16, BASE_DEC,
            NULL, 0, NULL, HFILL}},
 	{ &hf_scsi_osd_key_to_set,
-          {"Key to Set", "scsi.osd.key_to_set", FT_UINT8, BASE_DEC,
+          {"Key to Set", "scsi_osd.key_to_set", FT_UINT8, BASE_DEC,
            VALS(key_to_set_vals), 0x03, NULL, HFILL}},
 	{ &hf_scsi_osd_set_key_version,
-          {"Key Version", "scsi.osd.set_key_version", FT_UINT8, BASE_DEC,
+          {"Key Version", "scsi_osd.set_key_version", FT_UINT8, BASE_DEC,
            NULL, 0x0f, NULL, HFILL}},
 	{ &hf_scsi_osd_key_identifier,
-          {"Key Identifier", "scsi.osd.key_identifier", FT_BYTES, BASE_NONE,
+          {"Key Identifier", "scsi_osd.key_identifier", FT_BYTES, BASE_NONE,
            NULL, 0, NULL, HFILL}},
 	{ &hf_scsi_osd_seed,
-          {"Seed", "scsi.osd.seed", FT_BYTES, BASE_NONE,
+          {"Seed", "scsi_osd.seed", FT_BYTES, BASE_NONE,
            NULL, 0, NULL, HFILL}},
         { &hf_scsi_osd_collection_fcr,
-          {"FCR", "scsi.osd.collection.fcr", FT_BOOLEAN, 8,
+          {"FCR", "scsi_osd.collection.fcr", FT_BOOLEAN, 8,
            TFS(&collection_fcr_tfs), 0x01, NULL, HFILL}},
         { &hf_scsi_osd_collection_object_id,
-          {"Collection Object Id", "scsi.osd.collection_object_id", FT_BYTES, BASE_NONE,
+          {"Collection Object Id", "scsi_osd.collection_object_id", FT_BYTES, BASE_NONE,
            NULL, 0, NULL, HFILL}},
         { &hf_scsi_osd_requested_collection_object_id,
-          {"Requested Collection Object Id", "scsi.osd.requested_collection_object_id", FT_BYTES, BASE_NONE,
+          {"Requested Collection Object Id", "scsi_osd.requested_collection_object_id", FT_BYTES, BASE_NONE,
            NULL, 0, NULL, HFILL}},
         { &hf_scsi_osd_partition_created_in,
-          { "Created In", "scsi.osd.partition.created_in", FT_FRAMENUM, BASE_NONE,
+          { "Created In", "scsi_osd.partition.created_in", FT_FRAMENUM, BASE_NONE,
           NULL, 0x0, "The frame this partition was created", HFILL }},
 
         { &hf_scsi_osd_partition_removed_in,
-          { "Removed In", "scsi.osd.partition.removed_in", FT_FRAMENUM, BASE_NONE,
+          { "Removed In", "scsi_osd.partition.removed_in", FT_FRAMENUM, BASE_NONE,
           NULL, 0x0, "The frame this partition was removed", HFILL }},
 
 	{ &hf_scsi_osd_flush_scope,
-          {"Flush Scope", "scsi.osd.flush.scope", FT_UINT8, BASE_DEC,
+          {"Flush Scope", "scsi_osd.flush.scope", FT_UINT8, BASE_DEC,
            VALS(flush_scope_vals), 0x03, NULL, HFILL}},
 
 	{ &hf_scsi_osd_flush_collection_scope,
-          {"Flush Collection Scope", "scsi.osd.flush_collection.scope", FT_UINT8, BASE_DEC,
+          {"Flush Collection Scope", "scsi_osd.flush_collection.scope", FT_UINT8, BASE_DEC,
            VALS(flush_collection_scope_vals), 0x03, NULL, HFILL}},
 
 	{ &hf_scsi_osd_flush_partition_scope,
-          {"Flush Partition Scope", "scsi.osd.flush_partition.scope", FT_UINT8, BASE_DEC,
+          {"Flush Partition Scope", "scsi_osd.flush_partition.scope", FT_UINT8, BASE_DEC,
            VALS(flush_partition_scope_vals), 0x03, NULL, HFILL}},
 
 	{ &hf_scsi_osd_flush_osd_scope,
-          {"Flush OSD Scope", "scsi.osd.flush_osd.scope", FT_UINT8, BASE_DEC,
+          {"Flush OSD Scope", "scsi_osd.flush_osd.scope", FT_UINT8, BASE_DEC,
            VALS(flush_osd_scope_vals), 0x03, NULL, HFILL}},
 	{ &hf_scsi_osd_attributes_list_type,
-          {"Attributes List Type", "scsi.osd.attributes_list.type", FT_UINT8, BASE_HEX,
+          {"Attributes List Type", "scsi_osd.attributes_list.type", FT_UINT8, BASE_HEX,
            VALS(attributes_list_type_vals), 0x0f, NULL, HFILL}},
 	{ &hf_scsi_osd_attributes_list_length,
-          {"Attributes List Length", "scsi.osd.attributes_list.length", FT_UINT16, BASE_DEC,
+          {"Attributes List Length", "scsi_osd.attributes_list.length", FT_UINT16, BASE_DEC,
            NULL, 0, NULL, HFILL}},
 	{ &hf_scsi_osd_attributes_page,
-	  {"Attributes Page", "scsi.osd.attributes.page", FT_UINT32, BASE_HEX,
+	  {"Attributes Page", "scsi_osd.attributes.page", FT_UINT32, BASE_HEX,
 	  VALS(attributes_page_vals), 0, NULL, HFILL}},
 	{ &hf_scsi_osd_attribute_number,
-	  {"Attribute Number", "scsi.osd.attribute.number", FT_UINT32, BASE_HEX,
+	  {"Attribute Number", "scsi_osd.attribute.number", FT_UINT32, BASE_HEX,
 	  NULL, 0, NULL, HFILL}},
 	{ &hf_scsi_osd_attribute_length,
-	  {"Attribute Length", "scsi.osd.attribute.length", FT_UINT16, BASE_DEC,
+	  {"Attribute Length", "scsi_osd.attribute.length", FT_UINT16, BASE_DEC,
 	  NULL, 0, NULL, HFILL}},
 	{ &hf_scsi_osd_user_object_logical_length,
-	 {"User Object Logical Length", "scsi.osd.user_object.logical_length", FT_UINT64, BASE_DEC,
+	 {"User Object Logical Length", "scsi_osd.user_object.logical_length", FT_UINT64, BASE_DEC,
 	  NULL, 0, NULL, HFILL}},
 	};