2 * Copyright (c) 2007-2012 Zmanda, Inc. All Rights Reserved.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
11 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 * Contact information: Zmanda Inc., 465 S. Mathilda Ave., Suite 300
19 * Sunnyvale, CA 94085, USA, or: http://www.zmanda.com
25 #include "glib-util.h"
28 * Property-specific Types, etc.
31 static const GEnumValue _concurrency_paradigm_values[] = {
32 { CONCURRENCY_PARADIGM_EXCLUSIVE,
33 "CONCURRENCY_PARADIGM_EXCLUSIVE",
35 { CONCURRENCY_PARADIGM_SHARED_READ,
36 "CONCURRENCY_PARADIGM_SHARED_READ",
38 { CONCURRENCY_PARADIGM_RANDOM_ACCESS,
39 "CONCURRENCY_PARADIGM_RANDOM_ACCESS",
44 GType concurrency_paradigm_get_type (void) {
45 static GType type = 0;
46 if (G_UNLIKELY(type == 0)) {
47 type = g_enum_register_static ("ConcurrencyParadigm",
48 _concurrency_paradigm_values);
53 static const GEnumValue _streaming_requirement_values[] = {
54 { STREAMING_REQUIREMENT_NONE,
55 "STREAMING_REQUIREMENT_NONE",
57 { STREAMING_REQUIREMENT_DESIRED,
58 "STREAMING_REQUIREMENT_DESIRED",
60 { STREAMING_REQUIREMENT_REQUIRED,
61 "STREAMING_REQUIREMENT_REQUIRED",
66 GType streaming_requirement_get_type (void) {
67 static GType type = 0;
68 if (G_UNLIKELY(type == 0)) {
69 type = g_enum_register_static ("StreamingRequirement",
70 _streaming_requirement_values);
75 static const GEnumValue _media_access_mode_values[] = {
76 { MEDIA_ACCESS_MODE_READ_ONLY,
77 "MEDIA_ACCESS_MODE_READ_ONLY",
78 (char *)"read-only" },
79 { MEDIA_ACCESS_MODE_WORM,
80 "MEDIA_ACCESS_MODE_WORM",
81 (char *)"write-once-read-many" },
82 { MEDIA_ACCESS_MODE_READ_WRITE,
83 "MEDIA_ACCESS_MODE_READ_WRITE",
84 (char *)"read-write" },
85 { MEDIA_ACCESS_MODE_WRITE_ONLY,
86 "MEDIA_ACCESS_MODE_WRITE_ONLY",
87 (char *)"write-many-read-never" },
91 GType media_access_mode_get_type (void) {
92 static GType type = 0;
93 if (G_UNLIKELY(type == 0)) {
94 type = g_enum_register_static ("MediaAccessMode",
95 _media_access_mode_values);
101 * Property registration and lookup
104 static GPtrArray *device_property_bases = NULL;
105 static GHashTable *device_property_bases_by_name = NULL;
107 DevicePropertyBase* device_property_get_by_id(DevicePropertyId id) {
108 if (!device_property_bases || id >= device_property_bases->len)
111 return g_ptr_array_index(device_property_bases, id);
114 DevicePropertyBase* device_property_get_by_name(const char *name) {
117 if (!device_property_bases_by_name)
120 rv = g_hash_table_lookup(device_property_bases_by_name, name);
122 return (DevicePropertyBase *)rv;
127 #define toupper_and_underscore(c) (((c)=='-')? '_' : g_ascii_toupper((c)))
129 device_property_hash(
132 /* modified version of glib's hash function, copyright
133 * GLib Team and others 1997-2000. */
135 guint h = toupper_and_underscore(*p);
138 for (p += 1; *p != '\0'; p++)
139 h = (h << 5) - h + toupper_and_underscore(*p);
145 device_property_equal(
149 const char *s1 = v1, *s2 = v2;
152 if (toupper_and_underscore(*s1) != toupper_and_underscore(*s2))
163 device_property_fill_and_register(DevicePropertyBase *base,
164 GType type, const char * name, const char * desc) {
166 /* create the hash table and array if necessary */
167 if (!device_property_bases) {
168 device_property_bases = g_ptr_array_new();
169 device_property_bases_by_name = g_hash_table_new(device_property_hash, device_property_equal);
172 /* check for a duplicate */
173 if (device_property_get_by_name(name)) {
174 g_critical("A property named '%s' already exists!", name);
177 /* allocate space for this DPB and fill it in */
178 base->ID = device_property_bases->len;
180 base->name = name; /* no strdup -- it's statically allocated */
181 base->description = desc; /* ditto */
183 /* add it to the array and hash table; note that its array index and its
184 * ID are the same. */
185 g_ptr_array_add(device_property_bases, base);
186 g_hash_table_insert(device_property_bases_by_name, (gpointer)name, (gpointer)base);
193 void device_property_init(void) {
194 device_property_fill_and_register(&device_property_concurrency,
195 CONCURRENCY_PARADIGM_TYPE, "concurrency",
196 "Supported concurrency mode (none, multiple readers, multiple writers)");
197 device_property_fill_and_register(&device_property_streaming,
198 STREAMING_REQUIREMENT_TYPE, "streaming",
199 "Streaming desirability (unnecessary, desired, required)");
200 device_property_fill_and_register(&device_property_compression,
201 G_TYPE_BOOLEAN, "compression",
202 "Is device performing data compression?");
203 device_property_fill_and_register(&device_property_compression_rate,
204 G_TYPE_DOUBLE, "compression_rate",
206 "averaged for some (currently undefined) period of time)");
207 device_property_fill_and_register(&device_property_block_size,
208 G_TYPE_INT, "block_size",
209 "Block size to use while writing.");
210 device_property_fill_and_register(&device_property_min_block_size,
211 G_TYPE_UINT, "min_block_size",
212 "Minimum supported blocking factor.");
213 device_property_fill_and_register(&device_property_max_block_size,
214 G_TYPE_UINT, "max_block_size",
215 "Maximum supported blocking factor.");
216 device_property_fill_and_register(&device_property_read_block_size,
217 G_TYPE_UINT, "read_block_size",
218 "Minimum size of a read for this device (maximum expected block size)");
219 device_property_fill_and_register(&device_property_appendable,
220 G_TYPE_BOOLEAN, "appendable",
221 "Does device support appending to previously-written media?");
222 device_property_fill_and_register(&device_property_canonical_name,
223 G_TYPE_STRING, "canonical_name",
224 "The most reliable device name to use to refer to this device.");
225 device_property_fill_and_register(&device_property_medium_access_type,
226 MEDIA_ACCESS_MODE_TYPE,
227 "medium_access_type",
228 "What kind of media (RO/WORM/RW/WORN) do we have here?");
229 device_property_fill_and_register(&device_property_partial_deletion,
230 G_TYPE_BOOLEAN, "partial_deletion",
231 "Does this device support recycling just part of a volume?" );
232 device_property_fill_and_register(&device_property_full_deletion,
233 G_TYPE_BOOLEAN, "full_deletion",
234 "Does this device support recycling the entire volume?" );
235 device_property_fill_and_register(&device_property_max_volume_usage,
236 G_TYPE_UINT64, "max_volume_usage",
237 "Artificial limit to data written to volume.");
238 device_property_fill_and_register(&device_property_enforce_max_volume_usage,
239 G_TYPE_BOOLEAN, "enforce_max_volume_usage",
240 "Does max_volume_usage enabled?");
241 device_property_fill_and_register(&device_property_verbose,
242 G_TYPE_BOOLEAN, "verbose",
243 "Should the device produce verbose output?");
244 device_property_fill_and_register(&device_property_comment,
245 G_TYPE_STRING, "comment",
246 "User-specified comment for the device");
247 device_property_fill_and_register(&device_property_leom,
248 G_TYPE_BOOLEAN, "leom",
249 "Does this device support LEOM?");
252 DevicePropertyBase device_property_concurrency;
253 DevicePropertyBase device_property_streaming;
254 DevicePropertyBase device_property_compression;
255 DevicePropertyBase device_property_compression_rate;
256 DevicePropertyBase device_property_block_size;
257 DevicePropertyBase device_property_min_block_size;
258 DevicePropertyBase device_property_max_block_size;
259 DevicePropertyBase device_property_read_block_size;
260 DevicePropertyBase device_property_appendable;
261 DevicePropertyBase device_property_canonical_name;
262 DevicePropertyBase device_property_medium_access_type;
263 DevicePropertyBase device_property_partial_deletion;
264 DevicePropertyBase device_property_full_deletion;
265 DevicePropertyBase device_property_max_volume_usage;
266 DevicePropertyBase device_property_enforce_max_volume_usage;
267 DevicePropertyBase device_property_comment;
268 DevicePropertyBase device_property_leom;
269 DevicePropertyBase device_property_verbose;