/*
* Copyright (c) 2007-2012 Zmanda, Inc. All Rights Reserved.
* Copyright (c) 2013-2016 Carbonite, Inc. All Rights Reserved.
*
* 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
*
* Contact information: Carbonite Inc., 756 N Pastoria Ave
* Sunnyvale, CA 94085, or: http://www.zmanda.com
*/
#ifndef DEVICE_PROPERTY_H
#define DEVICE_PROPERTY_H
#include <glib.h>
#include <glib-object.h>
/* The properties interface defines define capabilities and other interesting
* properties. */
typedef enum {
PROPERTY_PHASE_BEFORE_START = (1 << 0),
PROPERTY_PHASE_BETWEEN_FILE_WRITE = (1 << 1),
PROPERTY_PHASE_INSIDE_FILE_WRITE = (1 << 2),
PROPERTY_PHASE_BETWEEN_FILE_READ = (1 << 3),
PROPERTY_PHASE_INSIDE_FILE_READ = (1 << 4),
PROPERTY_PHASE_MAX = (1 << 5)
} PropertyPhaseFlags;
#define PROPERTY_PHASE_MASK (PROPERTY_PHASE_MAX-1)
#define PROPERTY_PHASE_SHIFT 8
typedef enum {
PROPERTY_ACCESS_GET_BEFORE_START = (PROPERTY_PHASE_BEFORE_START),
PROPERTY_ACCESS_GET_BETWEEN_FILE_WRITE =
(PROPERTY_PHASE_BETWEEN_FILE_WRITE),
PROPERTY_ACCESS_GET_INSIDE_FILE_WRITE = (PROPERTY_PHASE_INSIDE_FILE_WRITE),
PROPERTY_ACCESS_GET_BETWEEN_FILE_READ =
(PROPERTY_PHASE_BETWEEN_FILE_READ),
PROPERTY_ACCESS_GET_INSIDE_FILE_READ = (PROPERTY_PHASE_INSIDE_FILE_READ),
PROPERTY_ACCESS_SET_BEFORE_START =
(PROPERTY_PHASE_BEFORE_START << PROPERTY_PHASE_SHIFT),
PROPERTY_ACCESS_SET_BETWEEN_FILE_WRITE =
(PROPERTY_PHASE_BETWEEN_FILE_WRITE << PROPERTY_PHASE_SHIFT),
PROPERTY_ACCESS_SET_INSIDE_FILE_WRITE =
(PROPERTY_PHASE_INSIDE_FILE_WRITE << PROPERTY_PHASE_SHIFT),
PROPERTY_ACCESS_SET_BETWEEN_FILE_READ =
(PROPERTY_PHASE_BETWEEN_FILE_READ << PROPERTY_PHASE_SHIFT),
PROPERTY_ACCESS_SET_INSIDE_FILE_READ =
(PROPERTY_PHASE_INSIDE_FILE_READ << PROPERTY_PHASE_SHIFT)
} PropertyAccessFlags;
#define PROPERTY_ACCESS_GET_MASK (PROPERTY_PHASE_MASK)
#define PROPERTY_ACCESS_SET_MASK (PROPERTY_PHASE_MASK << PROPERTY_PHASE_SHIFT)
/* Some properties can only be occasionally (or unreliably) detected, so
* this enum allows the user to override the detected or default
* setting. Surety indicates a level of confidence in the value, while
* source describes how we found out about it. */
typedef enum {
/* Support is not based on conclusive evidence. */
PROPERTY_SURETY_BAD,
/* Support is based on conclusive evidence. */
PROPERTY_SURETY_GOOD,
} PropertySurety;
typedef enum {
/* property is from default setting. */
PROPERTY_SOURCE_DEFAULT,
/* property is from device query. */
PROPERTY_SOURCE_DETECTED,
/* property is from user override (configuration). */
PROPERTY_SOURCE_USER,
} PropertySource;
/*****
* Initialization
*/
/* This should be called exactly once from device_api_init(). */
extern void device_property_init(void);
/* This structure is usually statically allocated. It holds information about
* a property that is common across all devices.
*/
typedef guint DevicePropertyId;
typedef struct {
DevicePropertyId ID; /* Set by device_property_register() */
GType type;
const char *name;
const char *description;
} DevicePropertyBase;
/* Registers a new property and returns its ID. This function takes ownership
* of its argument; it must not be freed later. It should be called from a
* device driver's registration function. */
extern DevicePropertyId device_property_register(DevicePropertyBase*);
/* Does the same thing, but fills in a new DevicePropertyBase with the given
* values first, and does not return the ID. This is more convenient for
* device-specific properties. */
extern void device_property_fill_and_register(
DevicePropertyBase * base,
GType type,
const char * name,
const char * desc);
/* Gets a DevicePropertyBase from its ID. */
DevicePropertyBase* device_property_get_by_id(DevicePropertyId);
DevicePropertyBase* device_property_get_by_name(const char*);
/*****
* Class-level Property Information
*/
/* This structure is held inside a Device object. It holds information about a
* property that is specific to the device driver, but not to a specific
* instance of the driver. */
struct Device; /* forward declaration */
typedef gboolean (*PropertySetFn)(
struct Device *self,
DevicePropertyBase *base,
GValue *val,
PropertySurety surety,
PropertySource source);
typedef gboolean (*PropertyGetFn)(
struct Device *self,
DevicePropertyBase *base,
GValue *val,
PropertySurety *surety,
PropertySource *source);
typedef struct {
DevicePropertyBase *base;
PropertyAccessFlags access;
PropertySetFn setter;
PropertyGetFn getter;
} DeviceProperty;
/*****
* Property-specific Types, etc.
*/
/* Standard property value types here.
* Important: see property.c for the other half of type declarations.*/
typedef enum {
CONCURRENCY_PARADIGM_EXCLUSIVE,
CONCURRENCY_PARADIGM_SHARED_READ,
CONCURRENCY_PARADIGM_RANDOM_ACCESS
} ConcurrencyParadigm;
#define CONCURRENCY_PARADIGM_TYPE concurrency_paradigm_get_type()
GType concurrency_paradigm_get_type (void);
#define STREAMING_REQUIREMENT_TYPE streaming_requirement_get_type()
GType streaming_requirement_get_type (void);
typedef enum {
MEDIA_ACCESS_MODE_READ_ONLY,
MEDIA_ACCESS_MODE_WORM,
MEDIA_ACCESS_MODE_READ_WRITE,
MEDIA_ACCESS_MODE_WRITE_ONLY
} MediaAccessMode;
#define MEDIA_ACCESS_MODE_TYPE media_access_mode_get_type()
GType media_access_mode_get_type (void);
/* Standard property definitions follow. See also property.c. */
/* Value is a ConcurrencyParadigm */
extern DevicePropertyBase device_property_concurrency;
#define PROPERTY_CONCURRENCY (device_property_concurrency.ID)
/* Value is a StreamingRequirement */
typedef enum {
STREAMING_REQUIREMENT_NONE,
STREAMING_REQUIREMENT_DESIRED,
STREAMING_REQUIREMENT_REQUIRED
} StreamingRequirement;
extern DevicePropertyBase device_property_streaming;
#define PROPERTY_STREAMING (device_property_streaming.ID)
/* Value is a gboolean. */
extern DevicePropertyBase device_property_compression;
#define PROPERTY_COMPRESSION (device_property_compression.ID)
/* Value is a gdouble, representing (compressed size)/(original
size). The period over which this value is measured is undefined. */
extern DevicePropertyBase device_property_compression_rate;
#define PROPERTY_COMPRESSION_RATE (device_property_compression_rate.ID)
/* Value is a gint; gives the write block size. */
extern DevicePropertyBase device_property_block_size;
#define PROPERTY_BLOCK_SIZE (device_property_block_size.ID)
/* Read-only. Value is a guint. */
extern DevicePropertyBase device_property_min_block_size;
extern DevicePropertyBase device_property_max_block_size;
#define PROPERTY_MIN_BLOCK_SIZE (device_property_min_block_size.ID)
#define PROPERTY_MAX_BLOCK_SIZE (device_property_max_block_size.ID)
/* Value is a guint; gives the minimum buffer size for reads. Only
* the tape device implements this, but it corresponds to the tapetype
* readblocksize parameter, so it's a global property*/
extern DevicePropertyBase device_property_read_block_size;
#define PROPERTY_READ_BLOCK_SIZE (device_property_read_block_size.ID)
/* Value is a gboolean. */
extern DevicePropertyBase device_property_appendable;
#define PROPERTY_APPENDABLE (device_property_appendable.ID)
/* Value is a string. */
extern DevicePropertyBase device_property_canonical_name;
#define PROPERTY_CANONICAL_NAME (device_property_canonical_name.ID)
/* Value is MediaAccessMode. */
extern DevicePropertyBase device_property_medium_access_type;
#define PROPERTY_MEDIUM_ACCESS_TYPE (device_property_medium_access_type.ID)
/* Value is a gboolean. */
extern DevicePropertyBase device_property_partial_deletion;
#define PROPERTY_PARTIAL_DELETION (device_property_partial_deletion.ID)
/* Value is a gboolean. */
extern DevicePropertyBase device_property_full_deletion;
#define PROPERTY_FULL_DELETION (device_property_full_deletion.ID)
/* Value is a guint64. On devices that support it, this property will
limit the total amount of data written to a volume; attempts to
write beyond this point will cause the device to simulate "out of
space". Zero means no limit. */
extern DevicePropertyBase device_property_max_volume_usage;
#define PROPERTY_MAX_VOLUME_USAGE (device_property_max_volume_usage.ID)
/* For devices supporting max_volume_usage this property will be used
disable/enable property max_volume_usage. If FALSE, max_volume_usage
will not be verified while writing to the device */
extern DevicePropertyBase device_property_enforce_max_volume_usage;
#define PROPERTY_ENFORCE_MAX_VOLUME_USAGE (device_property_enforce_max_volume_usage.ID)
/* Should the device produce verbose output? Value is a gboolean. Not
* present in all devices. */
extern DevicePropertyBase device_property_verbose;
#define PROPERTY_VERBOSE (device_property_verbose.ID)
/* A comment for the use of the user. */
extern DevicePropertyBase device_property_comment;
#define PROPERTY_COMMENT (device_property_comment.ID)
/* Does this device support LEOM? */
extern DevicePropertyBase device_property_leom;
#define PROPERTY_LEOM (device_property_leom.ID)
/* Whether to re-use connection. */
extern DevicePropertyBase device_property_reuse_connection;
#define PROPERTY_REUSE_CONNECTION (device_property_reuse_connection.ID)
/* Speed limits for sending and receiving */
extern DevicePropertyBase device_property_max_send_speed;
extern DevicePropertyBase device_property_max_recv_speed;
#define PROPERTY_MAX_SEND_SPEED (device_property_max_send_speed.ID)
#define PROPERTY_MAX_RECV_SPEED (device_property_max_recv_speed.ID)
/* Number of threads to use */
extern DevicePropertyBase device_property_nb_threads_backup;
#define PROPERTY_NB_THREADS_BACKUP (device_property_nb_threads_backup.ID)
extern DevicePropertyBase device_property_nb_threads_recovery;
#define PROPERTY_NB_THREADS_RECOVERY (device_property_nb_threads_recovery.ID)
/* use multi part upload must be used */
extern DevicePropertyBase device_property_multi_part_upload;
#define PROPERTY_MULTI_PART_UPLOAD (device_property_multi_part_upload.ID)
/* Path to certificate authority certificate */
extern DevicePropertyBase device_property_ssl_ca_info;
#define PROPERTY_SSL_CA_INFO (device_property_ssl_ca_info.ID)
/* proxy */
extern DevicePropertyBase device_property_proxy;
#define PROPERTY_PROXY (device_property_proxy.ID)
#endif