Line data Source code
1 234 : GQuark bd_fs_error_quark (void) {
2 234 : return g_quark_from_static_string ("g-bd-fs-error-quark");
3 : }
4 :
5 : /**
6 : * BDFSMkfsOptions:
7 : * @label: label of the filesystem
8 : * @uuid: uuid of the filesystem
9 : * @dry_run: whether to run mkfs in dry run mode (no changes written to the device)
10 : * @no_discard: whether to avoid discarding blocks at mkfs time
11 : * @force: whether to run mkfs with the `--force` (or similar) option, the behaviour of this
12 : * option depends on the filesystem, but in general it allows overwriting other
13 : * preexisting formats detected on the device
14 : * @no_pt: whether to disable (protective) partition table creation during mkfs
15 : * @reserve: reserve for future expansion
16 : */
17 : /**
18 : * bd_fs_mkfs_options_copy: (skip)
19 : * @data: (nullable): %BDFSMkfsOptions to copy
20 : *
21 : * Creates a new copy of @data.
22 : */
23 0 : BDFSMkfsOptions* bd_fs_mkfs_options_copy (BDFSMkfsOptions *data) {
24 0 : if (data == NULL)
25 0 : return NULL;
26 :
27 0 : BDFSMkfsOptions *ret = g_new0 (BDFSMkfsOptions, 1);
28 :
29 0 : ret->label = data->label;
30 0 : ret->uuid = data->uuid;
31 0 : ret->dry_run = data->dry_run;
32 0 : ret->no_discard = data->no_discard;
33 0 : ret->force = data->force;
34 0 : ret->no_pt = data->no_pt;
35 :
36 0 : return ret;
37 : }
38 :
39 : /**
40 : * bd_fs_mkfs_options_free: (skip)
41 : * @data: (nullable): %BDFSMkfsOptions to free
42 : *
43 : * Frees @data.
44 : */
45 0 : void bd_fs_mkfs_options_free (BDFSMkfsOptions *data) {
46 0 : if (data == NULL)
47 0 : return;
48 :
49 0 : g_free (data);
50 : }
51 :
52 323 : GType bd_fs_mkfs_options_get_type () {
53 : static GType type = 0;
54 :
55 323 : if (G_UNLIKELY(type == 0)) {
56 1 : type = g_boxed_type_register_static("BDFSMkfsOptions",
57 : (GBoxedCopyFunc) bd_fs_mkfs_options_copy,
58 : (GBoxedFreeFunc) bd_fs_mkfs_options_free);
59 : }
60 :
61 323 : return type;
62 : }
63 :
64 : /**
65 : * BDFSExtInfo:
66 : * @label: label of the filesystem
67 : * @uuid: uuid of the filesystem
68 : * @state: state of the filesystem (e.g. "clean")
69 : * @block_size: block size used by the filesystem
70 : * @block_count: number of blocks in the filesystem
71 : * @free_blocks: number of free blocks in the filesystem
72 : */
73 : /**
74 : * bd_fs_ext2_info_copy: (skip)
75 : * @data: (nullable): %BDFSExt2Info to copy
76 : *
77 : * Creates a new copy of @data.
78 : */
79 0 : BDFSExt2Info* bd_fs_ext2_info_copy (BDFSExt2Info *data) {
80 0 : if (data == NULL)
81 0 : return NULL;
82 :
83 0 : BDFSExt2Info *ret = g_new0 (BDFSExt2Info, 1);
84 :
85 0 : ret->label = g_strdup (data->label);
86 0 : ret->uuid = g_strdup (data->uuid);
87 0 : ret->state = g_strdup (data->state);
88 0 : ret->block_size = data->block_size;
89 0 : ret->block_count = data->block_count;
90 0 : ret->free_blocks = data->free_blocks;
91 :
92 0 : return ret;
93 : }
94 :
95 : /**
96 : * bd_fs_ext3_info_copy: (skip)
97 : * @data: (nullable): %BDFSExt3Info to copy
98 : *
99 : * Creates a new copy of @data.
100 : */
101 0 : BDFSExt3Info* bd_fs_ext3_info_copy (BDFSExt3Info *data) {
102 0 : return (BDFSExt3Info*) bd_fs_ext2_info_copy (data);
103 : }
104 :
105 : /**
106 : * bd_fs_ext4_info_copy: (skip)
107 : * @data: (nullable): %BDFSExt4Info to copy
108 : *
109 : * Creates a new copy of @data.
110 : */
111 0 : BDFSExt4Info* bd_fs_ext4_info_copy (BDFSExt4Info *data) {
112 0 : return (BDFSExt4Info*) bd_fs_ext2_info_copy (data);
113 : };
114 :
115 : /**
116 : * bd_fs_ext2_info_free: (skip)
117 : * @data: (nullable): %BDFSExt2Info to free
118 : *
119 : * Frees @data.
120 : */
121 88 : void bd_fs_ext2_info_free (BDFSExt2Info *data) {
122 88 : if (data == NULL)
123 0 : return;
124 :
125 88 : g_free (data->label);
126 88 : g_free (data->uuid);
127 88 : g_free (data->state);
128 88 : g_free (data);
129 : }
130 :
131 : /**
132 : * bd_fs_ext3_info_free: (skip)
133 : * @data: (nullable): %BDFSExt3Info to free
134 : *
135 : * Frees @data.
136 : */
137 18 : void bd_fs_ext3_info_free (BDFSExt3Info *data) {
138 18 : bd_fs_ext2_info_free ((BDFSExt2Info*) data);
139 18 : }
140 :
141 : /**
142 : * bd_fs_ext4_info_free: (skip)
143 : * @data: (nullable): %BDFSExt4Info to free
144 : *
145 : * Frees @data.
146 : */
147 45 : void bd_fs_ext4_info_free (BDFSExt4Info *data) {
148 45 : bd_fs_ext2_info_free ((BDFSExt2Info*) data);
149 45 : }
150 :
151 36 : GType bd_fs_ext2_info_get_type () {
152 : static GType type = 0;
153 :
154 36 : if (G_UNLIKELY(type == 0)) {
155 1 : type = g_boxed_type_register_static("BDFSExt2Info",
156 : (GBoxedCopyFunc) bd_fs_ext2_info_copy,
157 : (GBoxedFreeFunc) bd_fs_ext2_info_free);
158 : }
159 :
160 36 : return type;
161 : }
162 :
163 33 : GType bd_fs_ext3_info_get_type () {
164 : static GType type = 0;
165 :
166 33 : if (G_UNLIKELY(type == 0)) {
167 1 : type = g_boxed_type_register_static("BDFSExt3Info",
168 : (GBoxedCopyFunc) bd_fs_ext3_info_copy,
169 : (GBoxedFreeFunc) bd_fs_ext3_info_free);
170 : }
171 :
172 33 : return type;
173 : }
174 :
175 69 : GType bd_fs_ext4_info_get_type () {
176 : static GType type = 0;
177 :
178 69 : if (G_UNLIKELY(type == 0)) {
179 1 : type = g_boxed_type_register_static("BDFSExt4Info",
180 : (GBoxedCopyFunc) bd_fs_ext4_info_copy,
181 : (GBoxedFreeFunc) bd_fs_ext4_info_free);
182 : }
183 :
184 69 : return type;
185 : }
186 :
187 : /**
188 : * BDFSXfsInfo:
189 : * @label: label of the filesystem
190 : * @uuid: uuid of the filesystem
191 : * @block_size: block size used by the filesystem
192 : * @block_count: number of blocks in the filesystem
193 : */
194 : /**
195 : * bd_fs_xfs_info_copy: (skip)
196 : * @data: (nullable): %BDFSXfsInfo to copy
197 : *
198 : * Creates a new copy of @data.
199 : */
200 0 : BDFSXfsInfo* bd_fs_xfs_info_copy (BDFSXfsInfo *data) {
201 0 : if (data == NULL)
202 0 : return NULL;
203 :
204 0 : BDFSXfsInfo *ret = g_new0 (BDFSXfsInfo, 1);
205 :
206 0 : ret->label = g_strdup (data->label);
207 0 : ret->uuid = g_strdup (data->uuid);
208 0 : ret->block_size = data->block_size;
209 0 : ret->block_count = data->block_count;
210 :
211 0 : return ret;
212 : }
213 :
214 : /**
215 : * bd_fs_xfs_info_free: (skip)
216 : * @data: (nullable): %BDFSXfsInfo to free
217 : *
218 : * Frees @data.
219 : */
220 41 : void bd_fs_xfs_info_free (BDFSXfsInfo *data) {
221 41 : if (data == NULL)
222 0 : return;
223 :
224 41 : g_free (data->label);
225 41 : g_free (data->uuid);
226 41 : g_free (data);
227 : }
228 :
229 58 : GType bd_fs_xfs_info_get_type () {
230 : static GType type = 0;
231 :
232 58 : if (G_UNLIKELY(type == 0)) {
233 1 : type = g_boxed_type_register_static("BDFSXfsInfo",
234 : (GBoxedCopyFunc) bd_fs_xfs_info_copy,
235 : (GBoxedFreeFunc) bd_fs_xfs_info_free);
236 : }
237 :
238 58 : return type;
239 : }
240 :
241 : /**
242 : * BDFSVfatInfo:
243 : * @label: label of the filesystem
244 : * @uuid: uuid of the filesystem
245 : * @cluster_size: cluster size used by the filesystem
246 : * @cluster_count: number of clusters in the filesystem
247 : * @free_cluster_count: number of free clusters in the filesystem
248 : */
249 : /**
250 : * bd_fs_vfat_info_copy: (skip)
251 : * @data: (nullable): %BDFSVfatInfo to copy
252 : *
253 : * Creates a new copy of @data.
254 : */
255 0 : BDFSVfatInfo* bd_fs_vfat_info_copy (BDFSVfatInfo *data) {
256 0 : if (data == NULL)
257 0 : return NULL;
258 :
259 0 : BDFSVfatInfo *ret = g_new0 (BDFSVfatInfo, 1);
260 :
261 0 : ret->label = g_strdup (data->label);
262 0 : ret->uuid = g_strdup (data->uuid);
263 0 : ret->cluster_size = data->cluster_size;
264 0 : ret->cluster_count = data->cluster_count;
265 :
266 0 : return ret;
267 : }
268 :
269 : /**
270 : * bd_fs_vfat_info_free: (skip)
271 : * @data: (nullable): %BDFSVfatInfo to free
272 : *
273 : * Frees @data.
274 : */
275 19 : void bd_fs_vfat_info_free (BDFSVfatInfo *data) {
276 19 : if (data == NULL)
277 0 : return;
278 :
279 19 : g_free (data->label);
280 19 : g_free (data->uuid);
281 19 : g_free (data);
282 : }
283 :
284 17 : GType bd_fs_vfat_info_get_type () {
285 : static GType type = 0;
286 :
287 17 : if (G_UNLIKELY(type == 0)) {
288 1 : type = g_boxed_type_register_static("BDFSVfatInfo",
289 : (GBoxedCopyFunc) bd_fs_vfat_info_copy,
290 : (GBoxedFreeFunc) bd_fs_vfat_info_free);
291 : }
292 :
293 17 : return type;
294 : }
295 :
296 : /**
297 : * BDFSNtfsInfo:
298 : * @label: label of the filesystem
299 : * @uuid: uuid of the filesystem
300 : * @size: size of the filesystem in bytes
301 : * @free_space: number of free space in the filesystem in bytes
302 : */
303 : /**
304 : * bd_fs_ntfs_info_copy: (skip)
305 : * @data: (nullable): %BDFSNtfsInfo to copy
306 : *
307 : * Creates a new copy of @data.
308 : */
309 0 : BDFSNtfsInfo* bd_fs_ntfs_info_copy (BDFSNtfsInfo *data) {
310 0 : if (data == NULL)
311 0 : return NULL;
312 :
313 0 : BDFSNtfsInfo *ret = g_new0 (BDFSNtfsInfo, 1);
314 :
315 0 : ret->label = g_strdup (data->label);
316 0 : ret->uuid = g_strdup (data->uuid);
317 0 : ret->size = data->size;
318 0 : ret->free_space = data->free_space;
319 :
320 0 : return ret;
321 : }
322 :
323 : /**
324 : * bd_fs_ntfs_info_free: (skip)
325 : * @data: (nullable): %BDFSNtfsInfo to free
326 : *
327 : * Frees @data.
328 : */
329 17 : void bd_fs_ntfs_info_free (BDFSNtfsInfo *data) {
330 17 : if (data == NULL)
331 0 : return;
332 :
333 17 : g_free (data->label);
334 17 : g_free (data->uuid);
335 17 : g_free (data);
336 : }
337 :
338 21 : GType bd_fs_ntfs_info_get_type () {
339 : static GType type = 0;
340 :
341 21 : if (G_UNLIKELY(type == 0)) {
342 1 : type = g_boxed_type_register_static("BDFSNtfsInfo",
343 : (GBoxedCopyFunc) bd_fs_ntfs_info_copy,
344 : (GBoxedFreeFunc) bd_fs_ntfs_info_free);
345 : }
346 :
347 21 : return type;
348 : }
349 :
350 : /**
351 : * BDFSF2FSInfo:
352 : * @label: label of the filesystem
353 : * @uuid: uuid of the filesystem
354 : * @sector_size: sector size used by the filesystem
355 : * @sector_count: number of sectors in the filesystem
356 : * @features: features enabled for this filesystem, see #BDFSF2FSFeature
357 : */
358 : /**
359 : * bd_fs_f2fs_info_copy: (skip)
360 : * @data: (nullable): %BDFSF2FSInfo to copy
361 : *
362 : * Creates a new copy of @data.
363 : */
364 0 : BDFSF2FSInfo* bd_fs_f2fs_info_copy (BDFSF2FSInfo *data) {
365 0 : if (data == NULL)
366 0 : return NULL;
367 :
368 0 : BDFSF2FSInfo *ret = g_new0 (BDFSF2FSInfo, 1);
369 :
370 0 : ret->label = g_strdup (data->label);
371 0 : ret->uuid = g_strdup (data->uuid);
372 0 : ret->sector_size = data->sector_size;
373 0 : ret->sector_count = data->sector_count;
374 0 : ret->features = data->features;
375 :
376 0 : return ret;
377 : }
378 :
379 : /**
380 : * bd_fs_f2fs_info_free: (skip)
381 : * @data: (nullable): %BDFSF2FSInfo to free
382 : *
383 : * Frees @data.
384 : */
385 8 : void bd_fs_f2fs_info_free (BDFSF2FSInfo *data) {
386 8 : if (data == NULL)
387 0 : return;
388 :
389 8 : g_free (data->label);
390 8 : g_free (data->uuid);
391 8 : g_free (data);
392 : }
393 :
394 10 : GType bd_fs_f2fs_info_get_type () {
395 : static GType type = 0;
396 :
397 10 : if (G_UNLIKELY(type == 0)) {
398 1 : type = g_boxed_type_register_static("BDFSF2FSInfo",
399 : (GBoxedCopyFunc) bd_fs_f2fs_info_copy,
400 : (GBoxedFreeFunc) bd_fs_f2fs_info_free);
401 : }
402 :
403 10 : return type;
404 : }
405 :
406 : /**
407 : * BDFSNILFS2Info:
408 : * @label: label of the filesystem
409 : * @uuid: uuid of the filesystem
410 : * @block_size: block size used by the filesystem
411 : * @size: size of the filesystem
412 : * @free_blocks: number of free blocks in the filesystem
413 : */
414 : /**
415 : * bd_fs_nilfs2_info_copy: (skip)
416 : * @data: (nullable): %BDFSNILFS2Info to copy
417 : *
418 : * Creates a new copy of @data.
419 : */
420 0 : BDFSNILFS2Info* bd_fs_nilfs2_info_copy (BDFSNILFS2Info *data) {
421 0 : if (data == NULL)
422 0 : return NULL;
423 :
424 0 : BDFSNILFS2Info *ret = g_new0 (BDFSNILFS2Info, 1);
425 :
426 0 : ret->label = g_strdup (data->label);
427 0 : ret->uuid = g_strdup (data->uuid);
428 0 : ret->size = data->size;
429 0 : ret->block_size = data->block_size;
430 0 : ret->free_blocks = data->free_blocks;
431 :
432 0 : return ret;
433 : }
434 :
435 : /**
436 : * bd_fs_nilfs2_info_free: (skip)
437 : * @data: (nullable): %BDFSNILFS2Info to free
438 : *
439 : * Frees @data.
440 : */
441 17 : void bd_fs_nilfs2_info_free (BDFSNILFS2Info *data) {
442 17 : if (data == NULL)
443 0 : return;
444 :
445 17 : g_free (data->label);
446 17 : g_free (data->uuid);
447 17 : g_free (data);
448 : }
449 :
450 20 : GType bd_fs_nilfs2_info_get_type () {
451 : static GType type = 0;
452 :
453 20 : if (G_UNLIKELY(type == 0)) {
454 1 : type = g_boxed_type_register_static("BDFSNILFS2Info",
455 : (GBoxedCopyFunc) bd_fs_nilfs2_info_copy,
456 : (GBoxedFreeFunc) bd_fs_nilfs2_info_free);
457 : }
458 :
459 20 : return type;
460 : }
461 :
462 : /**
463 : * BDFSExfatInfo:
464 : * @label: label of the filesystem
465 : * @uuid: uuid of the filesystem
466 : * @sector_size: sector size used by the filesystem
467 : * @sector_count: number of sectors in the filesystem
468 : * @cluster_count: number of clusters in the filesystem
469 : */
470 : /**
471 : * bd_fs_exfat_info_free: (skip)
472 : * @data: (nullable): %BDFSExfatInfo to free
473 : *
474 : * Frees @data.
475 : */
476 11 : void bd_fs_exfat_info_free (BDFSExfatInfo *data) {
477 11 : if (data == NULL)
478 0 : return;
479 :
480 11 : g_free (data->label);
481 11 : g_free (data->uuid);
482 11 : g_free (data);
483 : }
484 :
485 : /**
486 : * bd_fs_exfat_info_copy: (skip)
487 : * @data: (nullable): %BDFSExfatInfo to copy
488 : *
489 : * Creates a new copy of @data.
490 : */
491 0 : BDFSExfatInfo* bd_fs_exfat_info_copy (BDFSExfatInfo *data) {
492 0 : if (data == NULL)
493 0 : return NULL;
494 :
495 0 : BDFSExfatInfo *ret = g_new0 (BDFSExfatInfo, 1);
496 :
497 0 : ret->label = g_strdup (data->label);
498 0 : ret->uuid = g_strdup (data->uuid);
499 0 : ret->sector_size = data->sector_size;
500 0 : ret->sector_count = data->sector_count;
501 0 : ret->cluster_count = data->cluster_count;
502 :
503 0 : return ret;
504 : }
505 :
506 19 : GType bd_fs_exfat_info_get_type () {
507 : static GType type = 0;
508 :
509 19 : if (G_UNLIKELY(type == 0)) {
510 1 : type = g_boxed_type_register_static("BDFSExfatInfo",
511 : (GBoxedCopyFunc) bd_fs_exfat_info_copy,
512 : (GBoxedFreeFunc) bd_fs_exfat_info_free);
513 : }
514 :
515 19 : return type;
516 : }
517 :
518 : /**
519 : * BDFSBtrfsInfo:
520 : * @label: label of the filesystem
521 : * @uuid: uuid of the filesystem
522 : * @size: size of the filesystem in bytes
523 : * @free_space: free space on the filesystem in bytes
524 : */
525 : /**
526 : * bd_fs_btrfs_info_copy: (skip)
527 : * @data: (nullable): %BDFSBtrfsInfo to copy
528 : *
529 : * Creates a new copy of @data.
530 : */
531 0 : BDFSBtrfsInfo* bd_fs_btrfs_info_copy (BDFSBtrfsInfo *data) {
532 0 : if (data == NULL)
533 0 : return NULL;
534 :
535 0 : BDFSBtrfsInfo *ret = g_new0 (BDFSBtrfsInfo, 1);
536 :
537 0 : ret->label = g_strdup (data->label);
538 0 : ret->uuid = g_strdup (data->uuid);
539 0 : ret->size = data->size;
540 0 : ret->free_space = data->free_space;
541 :
542 0 : return ret;
543 : }
544 :
545 : /**
546 : * bd_fs_btrfs_info_free: (skip)
547 : * @data: (nullable): %BDFSBtrfsInfo to free
548 : *
549 : * Frees @data.
550 : */
551 34 : void bd_fs_btrfs_info_free (BDFSBtrfsInfo *data) {
552 34 : if (data == NULL)
553 0 : return;
554 :
555 34 : g_free (data->label);
556 34 : g_free (data->uuid);
557 34 : g_free (data);
558 : }
559 :
560 24 : GType bd_fs_btrfs_info_get_type () {
561 : static GType type = 0;
562 :
563 24 : if (G_UNLIKELY(type == 0)) {
564 1 : type = g_boxed_type_register_static("BDFSBtrfsInfo",
565 : (GBoxedCopyFunc) bd_fs_btrfs_info_copy,
566 : (GBoxedFreeFunc) bd_fs_btrfs_info_free);
567 : }
568 :
569 24 : return type;
570 : }
571 :
572 : /**
573 : * BDFSUdfInfo:
574 : * @label: label of the filesystem
575 : * @uuid: uuid of the filesystem
576 : * @revision: UDF revision
577 : * @lvid: Logical Volume Identifier (most UDF implementations use this identifier as a disk label)
578 : * @vid: Volume Identifier
579 : * @block_size: block size used by the filesystem
580 : * @block_count: number of blocks in the filesystem
581 : * @free_blocks: number of free blocks in the filesystem
582 : */
583 : /**
584 : * bd_fs_udf_info_free: (skip)
585 : * @data: (nullable): %BDFSUdfInfo to free
586 : *
587 : * Frees @data.
588 : */
589 14 : void bd_fs_udf_info_free (BDFSUdfInfo *data) {
590 14 : if (data == NULL)
591 0 : return;
592 :
593 14 : g_free (data->label);
594 14 : g_free (data->uuid);
595 14 : g_free (data->revision);
596 14 : g_free (data->lvid);
597 14 : g_free (data->vid);
598 14 : g_free (data);
599 : }
600 :
601 : /**
602 : * bd_fs_udf_info_copy: (skip)
603 : * @data: (nullable): %BDFSUdfInfo to copy
604 : *
605 : * Creates a new copy of @data.
606 : */
607 0 : BDFSUdfInfo* bd_fs_udf_info_copy (BDFSUdfInfo *data) {
608 0 : if (data == NULL)
609 0 : return NULL;
610 :
611 0 : BDFSUdfInfo *ret = g_new0 (BDFSUdfInfo, 1);
612 :
613 0 : ret->label = g_strdup (data->label);
614 0 : ret->uuid = g_strdup (data->uuid);
615 0 : ret->revision = g_strdup (data->revision);
616 0 : ret->lvid = g_strdup (data->lvid);
617 0 : ret->vid = g_strdup (data->vid);
618 0 : ret->block_size = data->block_size;
619 0 : ret->block_count = data->block_count;
620 0 : ret->free_blocks = data->free_blocks;
621 :
622 0 : return ret;
623 : }
624 :
625 39 : GType bd_fs_udf_info_get_type () {
626 : static GType type = 0;
627 :
628 39 : if (G_UNLIKELY(type == 0)) {
629 1 : type = g_boxed_type_register_static("BDFSUdfInfo",
630 : (GBoxedCopyFunc) bd_fs_udf_info_copy,
631 : (GBoxedFreeFunc) bd_fs_udf_info_free);
632 : }
633 :
634 39 : return type;
635 : }
636 :
637 : /**
638 : * BDFSFeatures:
639 : * @resize: supported resizes modes
640 : * @mkfs: supported options for mkfs
641 : * @fsck: support for fsck operations (check and repair)
642 : * @configure: support for changing properties of an existing filesystem
643 : * @features: other supported features
644 : * @partition_id: partition ID used for this filesystem on MSDOS partitions
645 : * @partition_type: partition type/GUID used for this filesystem GPT partitions
646 : * @min_size: minimum size when creating this filesystem
647 : * @max_size: maximum size when creating this filesystem
648 : */
649 : /**
650 : * bd_fs_features_copy: (skip)
651 : * @data: (allow-none): %BDFSFeatures to copy
652 : *
653 : * Creates a new copy of @data.
654 : */
655 11 : BDFSFeatures* bd_fs_features_copy (BDFSFeatures *data) {
656 11 : if (data == NULL)
657 0 : return NULL;
658 :
659 11 : BDFSFeatures *ret = g_new0 (BDFSFeatures, 1);
660 :
661 11 : ret->resize = data->resize;
662 11 : ret->mkfs = data->mkfs;
663 11 : ret->fsck = data->fsck;
664 11 : ret->configure = data->configure;
665 11 : ret->features = data->features;
666 11 : ret->partition_id = data->partition_id;
667 11 : ret->partition_type = data->partition_type;
668 11 : ret->min_size = data->min_size;
669 11 : ret->max_size = data->max_size;
670 :
671 11 : return ret;
672 : }
673 :
674 : /**
675 : * bd_fs_features_free: (skip)
676 : * @data: (allow-none): %BDFSFeatures to free
677 : *
678 : * Frees @data.
679 : */
680 11 : void bd_fs_features_free (BDFSFeatures *data) {
681 11 : if (data == NULL)
682 0 : return;
683 :
684 11 : g_free (data);
685 : }
686 :
687 173 : GType bd_fs_features_get_type () {
688 : static GType type = 0;
689 :
690 173 : if (G_UNLIKELY(type == 0)) {
691 1 : type = g_boxed_type_register_static("BDFSFeatures",
692 : (GBoxedCopyFunc) bd_fs_features_copy,
693 : (GBoxedFreeFunc) bd_fs_features_free);
694 : }
695 :
696 173 : return type;
697 : }
698 :
699 0 : static gboolean bd_fs_is_tech_avail_stub (BDFSTech tech G_GNUC_UNUSED, guint64 mode G_GNUC_UNUSED, GError **error) {
700 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_is_tech_avail' called, but not implemented!");
701 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
702 : "The function 'bd_fs_is_tech_avail' called, but not implemented!");
703 0 : return FALSE;
704 : }
705 :
706 : static gboolean (*_bd_fs_is_tech_avail) (BDFSTech tech, guint64 mode, GError **error) = bd_fs_is_tech_avail_stub;
707 :
708 : /**
709 : * bd_fs_is_tech_avail:
710 : * @tech: the queried tech
711 : * @mode: a bit mask of queried modes of operation (#BDFSTechMode) for @tech
712 : * @error: (out) (optional): place to store error (details about why the @tech-@mode combination is not available)
713 : *
714 : * Returns: whether the @tech-@mode combination is available -- supported by the
715 : * plugin implementation and having all the runtime dependencies available
716 : */
717 624 : gboolean bd_fs_is_tech_avail (BDFSTech tech, guint64 mode, GError **error) {
718 624 : return _bd_fs_is_tech_avail (tech, mode, error);
719 : }
720 :
721 :
722 0 : static const gchar** bd_fs_supported_filesystems_stub (GError **error) {
723 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_supported_filesystems' called, but not implemented!");
724 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
725 : "The function 'bd_fs_supported_filesystems' called, but not implemented!");
726 0 : return NULL;
727 : }
728 :
729 : static const gchar** (*_bd_fs_supported_filesystems) (GError **error) = bd_fs_supported_filesystems_stub;
730 :
731 : /**
732 : * bd_fs_supported_filesystems:
733 : * @error: (out) (optional): currently unused
734 : *
735 : * Returns: (transfer container) (array zero-terminated=1): list of filesystems supported by this plugin
736 : *
737 : * Note: This returns filesystems supported by libblockdev, but not necessarily
738 : * by the systems this is running on, for this information you need to
739 : * run one of the `bd_fs_can_` functions.
740 : *
741 : * Tech category: always available
742 : */
743 1 : const gchar** bd_fs_supported_filesystems (GError **error) {
744 1 : return _bd_fs_supported_filesystems (error);
745 : }
746 :
747 :
748 0 : static gboolean bd_fs_wipe_stub (const gchar *device G_GNUC_UNUSED, gboolean all G_GNUC_UNUSED, gboolean force G_GNUC_UNUSED, GError **error) {
749 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_wipe' called, but not implemented!");
750 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
751 : "The function 'bd_fs_wipe' called, but not implemented!");
752 0 : return FALSE;
753 : }
754 :
755 : static gboolean (*_bd_fs_wipe) (const gchar *device, gboolean all, gboolean force, GError **error) = bd_fs_wipe_stub;
756 :
757 : /**
758 : * bd_fs_wipe:
759 : * @device: the device to wipe signatures from
760 : * @all: whether to wipe all (%TRUE) signatures or just the first (%FALSE) one
761 : * @force: whether to wipe signatures on a mounted @device
762 : * @error: (out) (optional): place to store error (if any)
763 : *
764 : * Returns: whether signatures were successfully wiped on @device or not
765 : *
766 : * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_WIPE
767 : */
768 116 : gboolean bd_fs_wipe (const gchar *device, gboolean all, gboolean force, GError **error) {
769 116 : return _bd_fs_wipe (device, all, force, error);
770 : }
771 :
772 :
773 0 : static gboolean bd_fs_clean_stub (const gchar *device G_GNUC_UNUSED, gboolean force G_GNUC_UNUSED, GError **error) {
774 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_clean' called, but not implemented!");
775 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
776 : "The function 'bd_fs_clean' called, but not implemented!");
777 0 : return FALSE;
778 : }
779 :
780 : static gboolean (*_bd_fs_clean) (const gchar *device, gboolean force, GError **error) = bd_fs_clean_stub;
781 :
782 : /**
783 : * bd_fs_clean:
784 : * @device: the device to clean
785 : * @force: whether to wipe signatures on a mounted @device
786 : * @error: (out) (optional): place to store error (if any)
787 : *
788 : * Clean all signatures from @device.
789 : * Difference between this and bd_fs_wipe() is that this function doesn't
790 : * return error if @device is already empty. This will also always remove
791 : * all signatures from @device, not only the first one.
792 : *
793 : * Returns: whether @device was successfully cleaned or not
794 : *
795 : * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_WIPE
796 : */
797 84 : gboolean bd_fs_clean (const gchar *device, gboolean force, GError **error) {
798 84 : return _bd_fs_clean (device, force, error);
799 : }
800 :
801 :
802 0 : static gchar* bd_fs_get_fstype_stub (const gchar *device G_GNUC_UNUSED, GError **error) {
803 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_get_fstype' called, but not implemented!");
804 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
805 : "The function 'bd_fs_get_fstype' called, but not implemented!");
806 0 : return NULL;
807 : }
808 :
809 : static gchar* (*_bd_fs_get_fstype) (const gchar *device, GError **error) = bd_fs_get_fstype_stub;
810 :
811 : /**
812 : * bd_fs_get_fstype:
813 : * @device: the device to probe
814 : * @error: (out) (optional): place to store error (if any)
815 : *
816 : * Get first signature on @device as a string.
817 : *
818 : * Returns: (transfer full): type of filesystem found on @device, %NULL in case
819 : * no signature has been detected or in case of error
820 : * (@error is set in this case)
821 : *
822 : * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
823 : */
824 140 : gchar* bd_fs_get_fstype (const gchar *device, GError **error) {
825 140 : return _bd_fs_get_fstype (device, error);
826 : }
827 :
828 :
829 0 : static gboolean bd_fs_freeze_stub (const gchar *mountpoint G_GNUC_UNUSED, GError **error) {
830 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_freeze' called, but not implemented!");
831 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
832 : "The function 'bd_fs_freeze' called, but not implemented!");
833 0 : return FALSE;
834 : }
835 :
836 : static gboolean (*_bd_fs_freeze) (const gchar *mountpoint, GError **error) = bd_fs_freeze_stub;
837 :
838 : /**
839 : * bd_fs_freeze:
840 : * @mountpoint: mountpoint of the device (filesystem) to freeze
841 : * @error: (out) (optional): place to store error (if any)
842 : *
843 : * Freezes filesystem mounted on @mountpoint. The filesystem must
844 : * support freezing.
845 : *
846 : * Returns: whether @mountpoint was successfully freezed or not
847 : *
848 : */
849 4 : gboolean bd_fs_freeze (const gchar *mountpoint, GError **error) {
850 4 : return _bd_fs_freeze (mountpoint, error);
851 : }
852 :
853 :
854 0 : static gboolean bd_fs_unfreeze_stub (const gchar *mountpoint G_GNUC_UNUSED, GError **error) {
855 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_unfreeze' called, but not implemented!");
856 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
857 : "The function 'bd_fs_unfreeze' called, but not implemented!");
858 0 : return FALSE;
859 : }
860 :
861 : static gboolean (*_bd_fs_unfreeze) (const gchar *mountpoint, GError **error) = bd_fs_unfreeze_stub;
862 :
863 : /**
864 : * bd_fs_unfreeze:
865 : * @mountpoint: mountpoint of the device (filesystem) to un-freeze
866 : * @error: (out) (optional): place to store error (if any)
867 : *
868 : * Un-freezes filesystem mounted on @mountpoint. The filesystem must
869 : * support freezing.
870 : *
871 : * Returns: whether @mountpoint was successfully unfreezed or not
872 : *
873 : */
874 3 : gboolean bd_fs_unfreeze (const gchar *mountpoint, GError **error) {
875 3 : return _bd_fs_unfreeze (mountpoint, error);
876 : }
877 :
878 :
879 0 : static gboolean bd_fs_unmount_stub (const gchar *spec G_GNUC_UNUSED, gboolean lazy G_GNUC_UNUSED, gboolean force G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
880 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_unmount' called, but not implemented!");
881 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
882 : "The function 'bd_fs_unmount' called, but not implemented!");
883 0 : return FALSE;
884 : }
885 :
886 : static gboolean (*_bd_fs_unmount) (const gchar *spec, gboolean lazy, gboolean force, const BDExtraArg **extra, GError **error) = bd_fs_unmount_stub;
887 :
888 : /**
889 : * bd_fs_unmount:
890 : * @spec: mount point or device to unmount
891 : * @lazy: enable/disable lazy unmount
892 : * @force: enable/disable force unmount
893 : * @extra: (nullable) (array zero-terminated=1): extra options for the unmount;
894 : * currently only 'run_as_uid'
895 : * and 'run_as_gid' are supported;
896 : * value must be a valid non zero
897 : * uid (gid), if you specify one of
898 : * these, the function will run in
899 : * a child process with real user
900 : * @error: (out) (optional): place to store error (if any)
901 : *
902 : * Returns: whether @spec was successfully unmounted or not
903 : *
904 : * Tech category: %BD_FS_TECH_MOUNT (no mode, ignored)
905 : */
906 35 : gboolean bd_fs_unmount (const gchar *spec, gboolean lazy, gboolean force, const BDExtraArg **extra, GError **error) {
907 35 : return _bd_fs_unmount (spec, lazy, force, extra, error);
908 : }
909 :
910 :
911 0 : static gboolean bd_fs_mount_stub (const gchar *device G_GNUC_UNUSED, const gchar *mountpoint G_GNUC_UNUSED, const gchar *fstype G_GNUC_UNUSED, const gchar *options G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
912 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_mount' called, but not implemented!");
913 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
914 : "The function 'bd_fs_mount' called, but not implemented!");
915 0 : return FALSE;
916 : }
917 :
918 : static gboolean (*_bd_fs_mount) (const gchar *device, const gchar *mountpoint, const gchar *fstype, const gchar *options, const BDExtraArg **extra, GError **error) = bd_fs_mount_stub;
919 :
920 : /**
921 : * bd_fs_mount:
922 : * @device: (nullable): device to mount, if not specified @mountpoint entry
923 : * from fstab will be used
924 : * @mountpoint: (nullable): mountpoint for @device, if not specified @device
925 : * entry from fstab will be used
926 : * @fstype: (nullable): filesystem type
927 : * @options: (nullable): comma delimited options for mount
928 : * @extra: (nullable) (array zero-terminated=1): extra options for the mount;
929 : * currently only 'run_as_uid'
930 : * and 'run_as_gid' are supported;
931 : * value must be a valid non zero
932 : * uid (gid), if you specify one of
933 : * these, the function will run in
934 : * a child process with real user
935 : * @error: (out) (optional): place to store error (if any)
936 : *
937 : * Returns: whether @device (or @mountpoint) was successfully mounted or not
938 : *
939 : * Tech category: %BD_FS_TECH_MOUNT (no mode, ignored)
940 : */
941 41 : gboolean bd_fs_mount (const gchar *device, const gchar *mountpoint, const gchar *fstype, const gchar *options, const BDExtraArg **extra, GError **error) {
942 41 : return _bd_fs_mount (device, mountpoint, fstype, options, extra, error);
943 : }
944 :
945 :
946 0 : static gchar* bd_fs_get_mountpoint_stub (const gchar *device G_GNUC_UNUSED, GError **error) {
947 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_get_mountpoint' called, but not implemented!");
948 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
949 : "The function 'bd_fs_get_mountpoint' called, but not implemented!");
950 0 : return NULL;
951 : }
952 :
953 : static gchar* (*_bd_fs_get_mountpoint) (const gchar *device, GError **error) = bd_fs_get_mountpoint_stub;
954 :
955 : /**
956 : * bd_fs_get_mountpoint:
957 : * @device: device to find mountpoint for
958 : * @error: (out) (optional): place to store error (if any)
959 : *
960 : * Get mountpoint for @device. If @device is mounted multiple times only
961 : * one mountpoint will be returned.
962 : *
963 : * Returns: (transfer full): mountpoint for @device, %NULL in case device is
964 : * not mounted or in case of an error (@error is set
965 : * in this case)
966 : *
967 : * Tech category: %BD_FS_TECH_MOUNT (no mode, ignored)
968 : */
969 91 : gchar* bd_fs_get_mountpoint (const gchar *device, GError **error) {
970 91 : return _bd_fs_get_mountpoint (device, error);
971 : }
972 :
973 :
974 0 : static gboolean bd_fs_is_mountpoint_stub (const gchar *path G_GNUC_UNUSED, GError **error) {
975 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_is_mountpoint' called, but not implemented!");
976 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
977 : "The function 'bd_fs_is_mountpoint' called, but not implemented!");
978 0 : return FALSE;
979 : }
980 :
981 : static gboolean (*_bd_fs_is_mountpoint) (const gchar *path, GError **error) = bd_fs_is_mountpoint_stub;
982 :
983 : /**
984 : * bd_fs_is_mountpoint:
985 : * @path: path (folder) to check
986 : * @error: (out) (optional): place to store error (if any)
987 : *
988 : * Returns: whether @path is a mountpoint or not
989 : *
990 : * Tech category: %BD_FS_TECH_MOUNT (no mode, ignored)
991 : */
992 9 : gboolean bd_fs_is_mountpoint (const gchar *path, GError **error) {
993 9 : return _bd_fs_is_mountpoint (path, error);
994 : }
995 :
996 :
997 0 : static gboolean bd_fs_resize_stub (const gchar *device G_GNUC_UNUSED, guint64 new_size G_GNUC_UNUSED, const gchar *fstype G_GNUC_UNUSED, GError **error) {
998 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_resize' called, but not implemented!");
999 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1000 : "The function 'bd_fs_resize' called, but not implemented!");
1001 0 : return FALSE;
1002 : }
1003 :
1004 : static gboolean (*_bd_fs_resize) (const gchar *device, guint64 new_size, const gchar *fstype, GError **error) = bd_fs_resize_stub;
1005 :
1006 : /**
1007 : * bd_fs_resize:
1008 : * @device: the device the file system of which to resize
1009 : * @new_size: new requested size for the file system (if 0, the file system is
1010 : * adapted to the underlying block device)
1011 : * @fstype: (nullable): the filesystem type on @device or %NULL to detect
1012 : * @error: (out) (optional): place to store error (if any)
1013 : *
1014 : * Resize filesystem on @device. This calls other fs resize functions from this
1015 : * plugin based on provides or detected filesystem (e.g. bd_fs_xfs_resize for XFS).
1016 : * This function will return an error for unknown/unsupported filesystems.
1017 : *
1018 : * Note: This function will mount @device for filesystems that can be resized only
1019 : * when mounted (like XFS or Btrfs).
1020 : *
1021 : * Returns: whether the file system on @device was successfully resized or not
1022 : *
1023 : * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_RESIZE
1024 : */
1025 30 : gboolean bd_fs_resize (const gchar *device, guint64 new_size, const gchar *fstype, GError **error) {
1026 30 : return _bd_fs_resize (device, new_size, fstype, error);
1027 : }
1028 :
1029 :
1030 0 : static gboolean bd_fs_repair_stub (const gchar *device G_GNUC_UNUSED, const gchar *fstype G_GNUC_UNUSED, GError **error) {
1031 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_repair' called, but not implemented!");
1032 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1033 : "The function 'bd_fs_repair' called, but not implemented!");
1034 0 : return FALSE;
1035 : }
1036 :
1037 : static gboolean (*_bd_fs_repair) (const gchar *device, const gchar *fstype, GError **error) = bd_fs_repair_stub;
1038 :
1039 : /**
1040 : * bd_fs_repair:
1041 : * @device: the device the file system of which to repair
1042 : * @fstype: (nullable): the filesystem type on @device or %NULL to detect
1043 : * @error: (out) (optional): place to store error (if any)
1044 : *
1045 : * Repair filesystem on @device. This calls other fs repair functions from this
1046 : * plugin based on detected filesystem (e.g. bd_fs_xfs_repair for XFS). This
1047 : * function will return an error for unknown/unsupported filesystems.
1048 : *
1049 : * Most filesystem tools typically require the filesystem not to be mounted.
1050 : *
1051 : * Returns: whether the file system on @device was successfully repaired or not
1052 : *
1053 : * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_REPAIR
1054 : */
1055 17 : gboolean bd_fs_repair (const gchar *device, const gchar *fstype, GError **error) {
1056 17 : return _bd_fs_repair (device, fstype, error);
1057 : }
1058 :
1059 :
1060 0 : static gboolean bd_fs_check_stub (const gchar *device G_GNUC_UNUSED, const gchar *fstype G_GNUC_UNUSED, GError **error) {
1061 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_check' called, but not implemented!");
1062 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1063 : "The function 'bd_fs_check' called, but not implemented!");
1064 0 : return FALSE;
1065 : }
1066 :
1067 : static gboolean (*_bd_fs_check) (const gchar *device, const gchar *fstype, GError **error) = bd_fs_check_stub;
1068 :
1069 : /**
1070 : * bd_fs_check:
1071 : * @device: the device the file system of which to check
1072 : * @fstype: (nullable): the filesystem type on @device or %NULL to detect
1073 : * @error: (out) (optional): place to store error (if any)
1074 : *
1075 : * Check filesystem on @device avoiding any modifications or repairs.
1076 : * This calls other fs check functions from this plugin based on detected
1077 : * filesystem (e.g. bd_fs_xfs_check for XFS). This function will return
1078 : * an error for unknown/unsupported filesystems.
1079 : *
1080 : * Note that depending on a corresponding filesystem type and configured
1081 : * features running this function on a mounted filesystem may result
1082 : * in false errors reported.
1083 : *
1084 : * Returns: whether the file system on @device passed the consistency check or not
1085 : *
1086 : * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_CHECK
1087 : */
1088 14 : gboolean bd_fs_check (const gchar *device, const gchar *fstype, GError **error) {
1089 14 : return _bd_fs_check (device, fstype, error);
1090 : }
1091 :
1092 :
1093 0 : static gboolean bd_fs_check_label_stub (const gchar *fstype G_GNUC_UNUSED, const gchar *label G_GNUC_UNUSED, GError **error) {
1094 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_check_label' called, but not implemented!");
1095 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1096 : "The function 'bd_fs_check_label' called, but not implemented!");
1097 0 : return FALSE;
1098 : }
1099 :
1100 : static gboolean (*_bd_fs_check_label) (const gchar *fstype, const gchar *label, GError **error) = bd_fs_check_label_stub;
1101 :
1102 : /**
1103 : * bd_fs_check_label:
1104 : * @fstype: the filesystem type to check @label for
1105 : * @label: label to check
1106 : * @error: (out) (optional): place to store error (if any)
1107 : *
1108 : * This calls other fs check label functions from this plugin based on the provided
1109 : * filesystem (e.g. bd_fs_xfs_check_label for XFS). This function will return
1110 : * an error for unknown/unsupported filesystems.
1111 : *
1112 : * Returns: whether @label is a valid label for the @fstype file system or not
1113 : * (reason is provided in @error)
1114 : *
1115 : * Tech category: always available
1116 : */
1117 20 : gboolean bd_fs_check_label (const gchar *fstype, const gchar *label, GError **error) {
1118 20 : return _bd_fs_check_label (fstype, label, error);
1119 : }
1120 :
1121 :
1122 0 : static gboolean bd_fs_set_label_stub (const gchar *device G_GNUC_UNUSED, const gchar *label G_GNUC_UNUSED, const gchar *fstype G_GNUC_UNUSED, GError **error) {
1123 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_set_label' called, but not implemented!");
1124 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1125 : "The function 'bd_fs_set_label' called, but not implemented!");
1126 0 : return FALSE;
1127 : }
1128 :
1129 : static gboolean (*_bd_fs_set_label) (const gchar *device, const gchar *label, const gchar *fstype, GError **error) = bd_fs_set_label_stub;
1130 :
1131 : /**
1132 : * bd_fs_set_label:
1133 : * @device: the device with file system to set the label for
1134 : * @label: label to set
1135 : * @fstype: (nullable): the filesystem type on @device or %NULL to detect
1136 : * @error: (out) (optional): place to store error (if any)
1137 : *
1138 : * Set label for filesystem on @device. This calls other fs label functions from this
1139 : * plugin based on detected filesystem (e.g. bd_fs_xfs_set_label for XFS). This
1140 : * function will return an error for unknown/unsupported filesystems.
1141 : *
1142 : * Note: This function will mount @device for filesystems that need to be mounted
1143 : * to set label (like btrfs).
1144 : *
1145 : * Returns: whether the file system on @device was successfully relabeled or not
1146 : *
1147 : * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_SET_LABEL
1148 : */
1149 17 : gboolean bd_fs_set_label (const gchar *device, const gchar *label, const gchar *fstype, GError **error) {
1150 17 : return _bd_fs_set_label (device, label, fstype, error);
1151 : }
1152 :
1153 :
1154 0 : static gboolean bd_fs_check_uuid_stub (const gchar *fstype G_GNUC_UNUSED, const gchar *uuid G_GNUC_UNUSED, GError **error) {
1155 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_check_uuid' called, but not implemented!");
1156 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1157 : "The function 'bd_fs_check_uuid' called, but not implemented!");
1158 0 : return FALSE;
1159 : }
1160 :
1161 : static gboolean (*_bd_fs_check_uuid) (const gchar *fstype, const gchar *uuid, GError **error) = bd_fs_check_uuid_stub;
1162 :
1163 : /**
1164 : * bd_fs_check_uuid:
1165 : * @fstype: the filesystem type to check @uuid for
1166 : * @uuid: uuid to check
1167 : * @error: (out) (optional): place to store error (if any)
1168 : *
1169 : * This calls other fs check uuid functions from this plugin based on the provided
1170 : * filesystem (e.g. bd_fs_xfs_check_uuid for XFS). This function will return
1171 : * an error for unknown/unsupported filesystems.
1172 : *
1173 : * Returns: whether @uuid is a valid UUID for the @fstype file system or not
1174 : * (reason is provided in @error)
1175 : *
1176 : * Tech category: always available
1177 : */
1178 10 : gboolean bd_fs_check_uuid (const gchar *fstype, const gchar *uuid, GError **error) {
1179 10 : return _bd_fs_check_uuid (fstype, uuid, error);
1180 : }
1181 :
1182 :
1183 0 : static gboolean bd_fs_set_uuid_stub (const gchar *device G_GNUC_UNUSED, const gchar *uuid G_GNUC_UNUSED, const gchar *fstype G_GNUC_UNUSED, GError **error) {
1184 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_set_uuid' called, but not implemented!");
1185 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1186 : "The function 'bd_fs_set_uuid' called, but not implemented!");
1187 0 : return FALSE;
1188 : }
1189 :
1190 : static gboolean (*_bd_fs_set_uuid) (const gchar *device, const gchar *uuid, const gchar *fstype, GError **error) = bd_fs_set_uuid_stub;
1191 :
1192 : /**
1193 : * bd_fs_set_uuid:
1194 : * @device: the device with file system to set the UUID for
1195 : * @uuid: (nullable): UUID to set or %NULL to generate a new one
1196 : * @fstype: (nullable): the filesystem type on @device or %NULL to detect
1197 : * @error: (out) (optional): place to store error (if any)
1198 : *
1199 : * Set UUID for filesystem on @device. This calls other fs UUID functions from this
1200 : * plugin based on detected filesystem (e.g. bd_fs_xfs_set_uuid for XFS). This
1201 : * function will return an error for unknown/unsupported filesystems.
1202 : *
1203 : * Returns: whether the UUID on the file system on @device was successfully changed or not
1204 : *
1205 : * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_SET_UUID
1206 : */
1207 17 : gboolean bd_fs_set_uuid (const gchar *device, const gchar *uuid, const gchar *fstype, GError **error) {
1208 17 : return _bd_fs_set_uuid (device, uuid, fstype, error);
1209 : }
1210 :
1211 :
1212 0 : static gboolean bd_fs_xfs_check_uuid_stub (const gchar *uuid G_GNUC_UNUSED, GError **error) {
1213 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_xfs_check_uuid' called, but not implemented!");
1214 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1215 : "The function 'bd_fs_xfs_check_uuid' called, but not implemented!");
1216 0 : return FALSE;
1217 : }
1218 :
1219 : static gboolean (*_bd_fs_xfs_check_uuid) (const gchar *uuid, GError **error) = bd_fs_xfs_check_uuid_stub;
1220 :
1221 : /**
1222 : * bd_fs_xfs_check_uuid:
1223 : * @uuid: UUID to check
1224 : * @error: (out) (optional): place to store error
1225 : *
1226 : * Returns: whether @uuid is a valid UUID for the xfs file system or not
1227 : * (reason is provided in @error)
1228 : *
1229 : * Tech category: always available
1230 : */
1231 4 : gboolean bd_fs_xfs_check_uuid (const gchar *uuid, GError **error) {
1232 4 : return _bd_fs_xfs_check_uuid (uuid, error);
1233 : }
1234 :
1235 :
1236 0 : static guint64 bd_fs_get_size_stub (const gchar *device G_GNUC_UNUSED, const gchar *fstype G_GNUC_UNUSED, GError **error) {
1237 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_get_size' called, but not implemented!");
1238 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1239 : "The function 'bd_fs_get_size' called, but not implemented!");
1240 0 : return 0;
1241 : }
1242 :
1243 : static guint64 (*_bd_fs_get_size) (const gchar *device, const gchar *fstype, GError **error) = bd_fs_get_size_stub;
1244 :
1245 : /**
1246 : * bd_fs_get_size:
1247 : * @device: the device with file system to get size for
1248 : * @fstype: (nullable): the filesystem type on @device or %NULL to detect
1249 : * @error: (out) (optional): place to store error (if any)
1250 : *
1251 : * Get size for filesystem on @device. This calls other fs info functions from this
1252 : * plugin based on detected filesystem (e.g. bd_fs_xfs_get_info for XFS). This
1253 : * function will return an error for unknown/unsupported filesystems.
1254 : *
1255 : * Note: This function will mount @device for filesystems that need to be mounted
1256 : * to gather information (like btrfs).
1257 : *
1258 : * Returns: size of filesystem on @device, 0 in case of error.
1259 : *
1260 : * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
1261 : */
1262 35 : guint64 bd_fs_get_size (const gchar *device, const gchar *fstype, GError **error) {
1263 35 : return _bd_fs_get_size (device, fstype, error);
1264 : }
1265 :
1266 :
1267 0 : static guint64 bd_fs_get_free_space_stub (const gchar *device G_GNUC_UNUSED, const gchar *fstype G_GNUC_UNUSED, GError **error) {
1268 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_get_free_space' called, but not implemented!");
1269 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1270 : "The function 'bd_fs_get_free_space' called, but not implemented!");
1271 0 : return 0;
1272 : }
1273 :
1274 : static guint64 (*_bd_fs_get_free_space) (const gchar *device, const gchar *fstype, GError **error) = bd_fs_get_free_space_stub;
1275 :
1276 : /**
1277 : * bd_fs_get_free_space:
1278 : * @device: the device with file system to get free space for
1279 : * @fstype: (nullable): the filesystem type on @device or %NULL to detect
1280 : * @error: (out) (optional): place to store error (if any)
1281 : *
1282 : * Get free space for filesystem on @device. This calls other fs info functions from this
1283 : * plugin based on detected filesystem (e.g. bd_fs_ext4_get_info for ext4). This
1284 : * function will return an error for unknown/unsupported filesystems.
1285 : *
1286 : * Returns: free space of filesystem on @device, 0 in case of error.
1287 : *
1288 : * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
1289 : */
1290 15 : guint64 bd_fs_get_free_space (const gchar *device, const gchar *fstype, GError **error) {
1291 15 : return _bd_fs_get_free_space (device, fstype, error);
1292 : }
1293 :
1294 :
1295 0 : static guint64 bd_fs_get_min_size_stub (const gchar *device G_GNUC_UNUSED, const gchar *fstype G_GNUC_UNUSED, GError **error) {
1296 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_get_min_size' called, but not implemented!");
1297 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1298 : "The function 'bd_fs_get_min_size' called, but not implemented!");
1299 0 : return 0;
1300 : }
1301 :
1302 : static guint64 (*_bd_fs_get_min_size) (const gchar *device, const gchar *fstype, GError **error) = bd_fs_get_min_size_stub;
1303 :
1304 : /**
1305 : * bd_fs_get_min_size:
1306 : * @device: the device with file system to get minimum size for
1307 : * @fstype: (nullable): the filesystem type on @device or %NULL to detect
1308 : * @error: (out) (optional): place to store error (if any)
1309 : *
1310 : * Get minimum size for filesystem on @device. This calls other fs info functions from this
1311 : * plugin based on detected filesystem (e.g. bd_fs_ext4_get_min_size for ext4). This
1312 : * function will return an error for unknown/unsupported filesystems.
1313 : *
1314 : * Returns: minimum size of filesystem on @device, 0 in case of error.
1315 : *
1316 : * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_RESIZE
1317 : */
1318 5 : guint64 bd_fs_get_min_size (const gchar *device, const gchar *fstype, GError **error) {
1319 5 : return _bd_fs_get_min_size (device, fstype, error);
1320 : }
1321 :
1322 :
1323 0 : static gboolean bd_fs_can_get_info_stub (const gchar *type G_GNUC_UNUSED, gchar **required_utility G_GNUC_UNUSED, GError **error) {
1324 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_can_get_info' called, but not implemented!");
1325 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1326 : "The function 'bd_fs_can_get_info' called, but not implemented!");
1327 0 : return FALSE;
1328 : }
1329 :
1330 : static gboolean (*_bd_fs_can_get_info) (const gchar *type, gchar **required_utility, GError **error) = bd_fs_can_get_info_stub;
1331 :
1332 : /**
1333 : * bd_fs_can_get_info:
1334 : * @type: the filesystem type to be tested for info querying support
1335 : * @required_utility: (out) (transfer full): the utility binary which is required
1336 : * for info querying (if missing i.e. return FALSE but no error)
1337 : * @error: (out) (optional): place to store error (if any)
1338 : *
1339 : * Searches for the required utility to get info of the given filesystem and
1340 : * returns whether it is installed.
1341 : * Unknown filesystems or filesystems which do not support info querying result in errors.
1342 : *
1343 : * Returns: whether getting filesystem info is available
1344 : *
1345 : * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
1346 : */
1347 3 : gboolean bd_fs_can_get_info (const gchar *type, gchar **required_utility, GError **error) {
1348 3 : return _bd_fs_can_get_info (type, required_utility, error);
1349 : }
1350 :
1351 :
1352 0 : static gboolean bd_fs_can_mkfs_stub (const gchar *type G_GNUC_UNUSED, BDFSMkfsOptionsFlags *options G_GNUC_UNUSED, gchar **required_utility G_GNUC_UNUSED, GError **error) {
1353 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_can_mkfs' called, but not implemented!");
1354 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1355 : "The function 'bd_fs_can_mkfs' called, but not implemented!");
1356 0 : return FALSE;
1357 : }
1358 :
1359 : static gboolean (*_bd_fs_can_mkfs) (const gchar *type, BDFSMkfsOptionsFlags *options, gchar **required_utility, GError **error) = bd_fs_can_mkfs_stub;
1360 :
1361 : /**
1362 : * BDFSMkfsOptionsFlags:
1363 : * Flags indicating mkfs options are available for given filesystem type.
1364 : */
1365 : /**
1366 : * bd_fs_can_mkfs:
1367 : * @type: the filesystem type to be tested for installed mkfs support
1368 : * @options: (out): flags for allowed mkfs options (i.e. support for setting label or UUID when creating the filesystem)
1369 : * @required_utility: (out) (transfer full): the utility binary which is required for creating (if missing returns %FALSE but no @error)
1370 : * @error: (out) (optional): place to store error (if any)
1371 : *
1372 : * Searches for the required utility to create the given filesystem and returns whether
1373 : * it is installed. The options flags indicate what additional options can be specified for @type.
1374 : * Unknown filesystems result in errors.
1375 : *
1376 : * Returns: whether filesystem mkfs tool is available
1377 : *
1378 : * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
1379 : */
1380 22 : gboolean bd_fs_can_mkfs (const gchar *type, BDFSMkfsOptionsFlags *options, gchar **required_utility, GError **error) {
1381 22 : return _bd_fs_can_mkfs (type, options, required_utility, error);
1382 : }
1383 :
1384 :
1385 0 : static gboolean bd_fs_can_resize_stub (const gchar *type G_GNUC_UNUSED, BDFSResizeFlags *mode G_GNUC_UNUSED, gchar **required_utility G_GNUC_UNUSED, GError **error) {
1386 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_can_resize' called, but not implemented!");
1387 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1388 : "The function 'bd_fs_can_resize' called, but not implemented!");
1389 0 : return FALSE;
1390 : }
1391 :
1392 : static gboolean (*_bd_fs_can_resize) (const gchar *type, BDFSResizeFlags *mode, gchar **required_utility, GError **error) = bd_fs_can_resize_stub;
1393 :
1394 : /**
1395 : * BDFSResizeFlags:
1396 : * Flags indicating whether a filesystem resize action supports growing and/or
1397 : * shrinking if mounted or unmounted.
1398 : */
1399 : /**
1400 : * bd_fs_can_resize:
1401 : * @type: the filesystem type to be tested for installed resize support
1402 : * @mode: (out): flags for allowed resizing (i.e. growing/shrinking support for online/offline)
1403 : * @required_utility: (out) (transfer full): the utility binary which is required for resizing (if missing i.e. returns FALSE but no error)
1404 : * @error: (out) (optional): place to store error (if any)
1405 : *
1406 : * Searches for the required utility to resize the given filesystem and returns whether
1407 : * it is installed. The mode flags indicate if growing and/or shrinking resize is available if
1408 : * mounted/unmounted.
1409 : * Unknown filesystems or filesystems which do not support resizing result in errors.
1410 : *
1411 : * Returns: whether filesystem resize is available
1412 : *
1413 : * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
1414 : */
1415 5 : gboolean bd_fs_can_resize (const gchar *type, BDFSResizeFlags *mode, gchar **required_utility, GError **error) {
1416 5 : return _bd_fs_can_resize (type, mode, required_utility, error);
1417 : }
1418 :
1419 :
1420 0 : static gboolean bd_fs_can_check_stub (const gchar *type G_GNUC_UNUSED, gchar **required_utility G_GNUC_UNUSED, GError **error) {
1421 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_can_check' called, but not implemented!");
1422 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1423 : "The function 'bd_fs_can_check' called, but not implemented!");
1424 0 : return FALSE;
1425 : }
1426 :
1427 : static gboolean (*_bd_fs_can_check) (const gchar *type, gchar **required_utility, GError **error) = bd_fs_can_check_stub;
1428 :
1429 : /**
1430 : * bd_fs_can_check:
1431 : * @type: the filesystem type to be tested for installed consistency check support
1432 : * @required_utility: (out) (transfer full): the utility binary which is required for checking (if missing i.e. returns FALSE but no error)
1433 : * @error: (out) (optional): place to store error (if any)
1434 : *
1435 : * Searches for the required utility to check the given filesystem and returns whether
1436 : * it is installed.
1437 : * Unknown filesystems or filesystems which do not support checking result in errors.
1438 : *
1439 : * Returns: whether filesystem check is available
1440 : *
1441 : * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
1442 : */
1443 5 : gboolean bd_fs_can_check (const gchar *type, gchar **required_utility, GError **error) {
1444 5 : return _bd_fs_can_check (type, required_utility, error);
1445 : }
1446 :
1447 :
1448 0 : static gboolean bd_fs_can_repair_stub (const gchar *type G_GNUC_UNUSED, gchar **required_utility G_GNUC_UNUSED, GError **error) {
1449 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_can_repair' called, but not implemented!");
1450 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1451 : "The function 'bd_fs_can_repair' called, but not implemented!");
1452 0 : return FALSE;
1453 : }
1454 :
1455 : static gboolean (*_bd_fs_can_repair) (const gchar *type, gchar **required_utility, GError **error) = bd_fs_can_repair_stub;
1456 :
1457 : /**
1458 : * bd_fs_can_repair:
1459 : * @type: the filesystem type to be tested for installed repair support
1460 : * @required_utility: (out) (transfer full): the utility binary which is required for repairing (if missing i.e. return FALSE but no error)
1461 : * @error: (out) (optional): place to store error (if any)
1462 : *
1463 : * Searches for the required utility to repair the given filesystem and returns whether
1464 : * it is installed.
1465 : * Unknown filesystems or filesystems which do not support reparing result in errors.
1466 : *
1467 : * Returns: whether filesystem repair is available
1468 : *
1469 : * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
1470 : */
1471 5 : gboolean bd_fs_can_repair (const gchar *type, gchar **required_utility, GError **error) {
1472 5 : return _bd_fs_can_repair (type, required_utility, error);
1473 : }
1474 :
1475 :
1476 0 : static gboolean bd_fs_can_set_label_stub (const gchar *type G_GNUC_UNUSED, gchar **required_utility G_GNUC_UNUSED, GError **error) {
1477 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_can_set_label' called, but not implemented!");
1478 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1479 : "The function 'bd_fs_can_set_label' called, but not implemented!");
1480 0 : return FALSE;
1481 : }
1482 :
1483 : static gboolean (*_bd_fs_can_set_label) (const gchar *type, gchar **required_utility, GError **error) = bd_fs_can_set_label_stub;
1484 :
1485 : /**
1486 : * bd_fs_can_set_label:
1487 : * @type: the filesystem type to be tested for installed label support
1488 : * @required_utility: (out) (transfer full): the utility binary which is required for relabeling (if missing i.e. return FALSE but no error)
1489 : * @error: (out) (optional): place to store error (if any)
1490 : *
1491 : * Searches for the required utility to set the label of the given filesystem and returns whether
1492 : * it is installed.
1493 : * Unknown filesystems or filesystems which do not support setting the label result in errors.
1494 : *
1495 : * Returns: whether setting filesystem label is available
1496 : *
1497 : * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
1498 : */
1499 3 : gboolean bd_fs_can_set_label (const gchar *type, gchar **required_utility, GError **error) {
1500 3 : return _bd_fs_can_set_label (type, required_utility, error);
1501 : }
1502 :
1503 :
1504 0 : static gboolean bd_fs_can_set_uuid_stub (const gchar *type G_GNUC_UNUSED, gchar **required_utility G_GNUC_UNUSED, GError **error) {
1505 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_can_set_uuid' called, but not implemented!");
1506 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1507 : "The function 'bd_fs_can_set_uuid' called, but not implemented!");
1508 0 : return FALSE;
1509 : }
1510 :
1511 : static gboolean (*_bd_fs_can_set_uuid) (const gchar *type, gchar **required_utility, GError **error) = bd_fs_can_set_uuid_stub;
1512 :
1513 : /**
1514 : * bd_fs_can_set_uuid:
1515 : * @type: the filesystem type to be tested for installed UUID support
1516 : * @required_utility: (out) (transfer full): the utility binary which is required for setting UUID (if missing i.e. return FALSE but no error)
1517 : * @error: (out) (optional): place to store error (if any)
1518 : *
1519 : * Searches for the required utility to set the UUID of the given filesystem and returns whether
1520 : * it is installed.
1521 : * Unknown filesystems or filesystems which do not support setting the UUID result in errors.
1522 : *
1523 : * Returns: whether setting filesystem UUID is available
1524 : *
1525 : * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
1526 : */
1527 4 : gboolean bd_fs_can_set_uuid (const gchar *type, gchar **required_utility, GError **error) {
1528 4 : return _bd_fs_can_set_uuid (type, required_utility, error);
1529 : }
1530 :
1531 :
1532 0 : static gboolean bd_fs_can_get_size_stub (const gchar *type G_GNUC_UNUSED, gchar **required_utility G_GNUC_UNUSED, GError **error) {
1533 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_can_get_size' called, but not implemented!");
1534 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1535 : "The function 'bd_fs_can_get_size' called, but not implemented!");
1536 0 : return FALSE;
1537 : }
1538 :
1539 : static gboolean (*_bd_fs_can_get_size) (const gchar *type, gchar **required_utility, GError **error) = bd_fs_can_get_size_stub;
1540 :
1541 : /**
1542 : * bd_fs_can_get_size:
1543 : * @type: the filesystem type to be tested for installed size querying support
1544 : * @required_utility: (out) (transfer full): the utility binary which is required
1545 : * for size querying (if missing i.e. return FALSE but no error)
1546 : * @error: (out) (optional): place to store error (if any)
1547 : *
1548 : * Searches for the required utility to get size of the given filesystem and
1549 : * returns whether it is installed.
1550 : * Unknown filesystems or filesystems which do not support size querying result in errors.
1551 : *
1552 : * Returns: whether getting filesystem size is available
1553 : *
1554 : * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
1555 : */
1556 3 : gboolean bd_fs_can_get_size (const gchar *type, gchar **required_utility, GError **error) {
1557 3 : return _bd_fs_can_get_size (type, required_utility, error);
1558 : }
1559 :
1560 :
1561 0 : static gboolean bd_fs_can_get_free_space_stub (const gchar *type G_GNUC_UNUSED, gchar **required_utility G_GNUC_UNUSED, GError **error) {
1562 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_can_get_free_space' called, but not implemented!");
1563 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1564 : "The function 'bd_fs_can_get_free_space' called, but not implemented!");
1565 0 : return FALSE;
1566 : }
1567 :
1568 : static gboolean (*_bd_fs_can_get_free_space) (const gchar *type, gchar **required_utility, GError **error) = bd_fs_can_get_free_space_stub;
1569 :
1570 : /**
1571 : * bd_fs_can_get_free_space:
1572 : * @type: the filesystem type to be tested for installed free space querying support
1573 : * @required_utility: (out) (transfer full): the utility binary which is required
1574 : * for free space querying (if missing i.e. return FALSE but no error)
1575 : * @error: (out) (optional): place to store error (if any)
1576 : *
1577 : * Searches for the required utility to get free space of the given filesystem and
1578 : * returns whether it is installed.
1579 : * Unknown filesystems or filesystems which do not support free space querying result in errors.
1580 : *
1581 : * Returns: whether getting filesystem free space is available
1582 : *
1583 : * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
1584 : */
1585 6 : gboolean bd_fs_can_get_free_space (const gchar *type, gchar **required_utility, GError **error) {
1586 6 : return _bd_fs_can_get_free_space (type, required_utility, error);
1587 : }
1588 :
1589 :
1590 0 : static gboolean bd_fs_can_get_min_size_stub (const gchar *type G_GNUC_UNUSED, gchar **required_utility G_GNUC_UNUSED, GError **error) {
1591 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_can_get_min_size' called, but not implemented!");
1592 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1593 : "The function 'bd_fs_can_get_min_size' called, but not implemented!");
1594 0 : return FALSE;
1595 : }
1596 :
1597 : static gboolean (*_bd_fs_can_get_min_size) (const gchar *type, gchar **required_utility, GError **error) = bd_fs_can_get_min_size_stub;
1598 :
1599 : /**
1600 : * bd_fs_can_get_min_size:
1601 : * @type: the filesystem type to be tested for installed minimum size querying support
1602 : * @required_utility: (out) (transfer full): the utility binary which is required
1603 : * for size querying (if missing i.e. return FALSE but no error)
1604 : * @error: (out) (optional): place to store error (if any)
1605 : *
1606 : * Searches for the required utility to get minimum size of the given filesystem and
1607 : * returns whether it is installed.
1608 : * Unknown filesystems or filesystems which do not support minimum size querying result in errors.
1609 : *
1610 : * Returns: whether getting filesystem size is available
1611 : *
1612 : * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
1613 : */
1614 7 : gboolean bd_fs_can_get_min_size (const gchar *type, gchar **required_utility, GError **error) {
1615 7 : return _bd_fs_can_get_min_size (type, required_utility, error);
1616 : }
1617 :
1618 :
1619 0 : static gboolean bd_fs_mkfs_stub (const gchar *device G_GNUC_UNUSED, const gchar *fstype G_GNUC_UNUSED, BDFSMkfsOptions *options G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
1620 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_mkfs' called, but not implemented!");
1621 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1622 : "The function 'bd_fs_mkfs' called, but not implemented!");
1623 0 : return FALSE;
1624 : }
1625 :
1626 : static gboolean (*_bd_fs_mkfs) (const gchar *device, const gchar *fstype, BDFSMkfsOptions *options, const BDExtraArg **extra, GError **error) = bd_fs_mkfs_stub;
1627 :
1628 : /**
1629 : * bd_fs_mkfs:
1630 : * @device: the device to create the new filesystem on
1631 : * @fstype: name of the filesystem to create (e.g. "ext4")
1632 : * @options: additional options like label or UUID for the filesystem
1633 : * @extra: (nullable) (array zero-terminated=1): extra mkfs options not provided in @options
1634 : * @error: (out) (optional): place to store error (if any)
1635 : *
1636 : * This is a helper function for creating filesystems with extra options.
1637 : * This is the same as running a filesystem-specific function like %bd_fs_ext4_mkfs
1638 : * and manually specifying the extra command line options. %BDFSMkfsOptions
1639 : * removes the need to specify supported options for selected filesystems,
1640 : * make sure to check whether @fstype supports these options (see %bd_fs_can_mkfs)
1641 : * for details.
1642 : *
1643 : * When specifying additional mkfs options using @extra, it's caller's
1644 : * responsibility to make sure these options do not conflict with options
1645 : * specified using @options. Extra options are added after the @options and
1646 : * there are no additional checks for duplicate and/or conflicting options.
1647 : *
1648 : * Returns: whether @fstype was successfully created on @device or not.
1649 : *
1650 : * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_MKFS
1651 : *
1652 : */
1653 53 : gboolean bd_fs_mkfs (const gchar *device, const gchar *fstype, BDFSMkfsOptions *options, const BDExtraArg **extra, GError **error) {
1654 53 : return _bd_fs_mkfs (device, fstype, options, extra, error);
1655 : }
1656 :
1657 :
1658 0 : static gboolean bd_fs_ext2_mkfs_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
1659 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext2_mkfs' called, but not implemented!");
1660 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1661 : "The function 'bd_fs_ext2_mkfs' called, but not implemented!");
1662 0 : return FALSE;
1663 : }
1664 :
1665 : static gboolean (*_bd_fs_ext2_mkfs) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_ext2_mkfs_stub;
1666 :
1667 : /**
1668 : * bd_fs_ext2_mkfs:
1669 : * @device: the device to create a new ext2 fs on
1670 : * @extra: (nullable) (array zero-terminated=1): extra options for the creation (right now
1671 : * passed to the 'mke2fs' utility)
1672 : * @error: (out) (optional): place to store error (if any)
1673 : *
1674 : * Returns: whether a new ext2 fs was successfully created on @device or not
1675 : *
1676 : * Tech category: %BD_FS_TECH_EXT2-%BD_FS_TECH_MODE_MKFS
1677 : */
1678 17 : gboolean bd_fs_ext2_mkfs (const gchar *device, const BDExtraArg **extra, GError **error) {
1679 17 : return _bd_fs_ext2_mkfs (device, extra, error);
1680 : }
1681 :
1682 :
1683 0 : static gboolean bd_fs_ext3_mkfs_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
1684 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext3_mkfs' called, but not implemented!");
1685 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1686 : "The function 'bd_fs_ext3_mkfs' called, but not implemented!");
1687 0 : return FALSE;
1688 : }
1689 :
1690 : static gboolean (*_bd_fs_ext3_mkfs) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_ext3_mkfs_stub;
1691 :
1692 : /**
1693 : * bd_fs_ext3_mkfs:
1694 : * @device: the device to create a new ext3 fs on
1695 : * @extra: (nullable) (array zero-terminated=1): extra options for the creation (right now
1696 : * passed to the 'mke2fs' utility)
1697 : * @error: (out) (optional): place to store error (if any)
1698 : *
1699 : * Returns: whether a new ext3 fs was successfully created on @device or not
1700 : *
1701 : * Tech category: %BD_FS_TECH_EXT3-%BD_FS_TECH_MODE_MKFS
1702 : */
1703 15 : gboolean bd_fs_ext3_mkfs (const gchar *device, const BDExtraArg **extra, GError **error) {
1704 15 : return _bd_fs_ext3_mkfs (device, extra, error);
1705 : }
1706 :
1707 :
1708 0 : static gboolean bd_fs_ext4_mkfs_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
1709 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext4_mkfs' called, but not implemented!");
1710 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1711 : "The function 'bd_fs_ext4_mkfs' called, but not implemented!");
1712 0 : return FALSE;
1713 : }
1714 :
1715 : static gboolean (*_bd_fs_ext4_mkfs) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_ext4_mkfs_stub;
1716 :
1717 : /**
1718 : * bd_fs_ext4_mkfs:
1719 : * @device: the device to create a new ext4 fs on
1720 : * @extra: (nullable) (array zero-terminated=1): extra options for the creation (right now
1721 : * passed to the 'mkfs.ext4' utility)
1722 : * @error: (out) (optional): place to store error (if any)
1723 : *
1724 : * Returns: whether a new ext4 fs was successfully created on @device or not
1725 : *
1726 : * Tech category: %BD_FS_TECH_EXT4-%BD_FS_TECH_MODE_MKFS
1727 : */
1728 23 : gboolean bd_fs_ext4_mkfs (const gchar *device, const BDExtraArg **extra, GError **error) {
1729 23 : return _bd_fs_ext4_mkfs (device, extra, error);
1730 : }
1731 :
1732 :
1733 0 : static gboolean bd_fs_ext2_check_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
1734 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext2_check' called, but not implemented!");
1735 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1736 : "The function 'bd_fs_ext2_check' called, but not implemented!");
1737 0 : return FALSE;
1738 : }
1739 :
1740 : static gboolean (*_bd_fs_ext2_check) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_ext2_check_stub;
1741 :
1742 : /**
1743 : * bd_fs_ext2_check:
1744 : * @device: the device the file system on which to check
1745 : * @extra: (nullable) (array zero-terminated=1): extra options for the check (right now
1746 : * passed to the 'e2fsck' utility)
1747 : * @error: (out) (optional): place to store error (if any)
1748 : *
1749 : * Returns: whether an ext2 file system on the @device is clean or not
1750 : *
1751 : * Tech category: %BD_FS_TECH_EXT2-%BD_FS_TECH_MODE_CHECK
1752 : */
1753 1 : gboolean bd_fs_ext2_check (const gchar *device, const BDExtraArg **extra, GError **error) {
1754 1 : return _bd_fs_ext2_check (device, extra, error);
1755 : }
1756 :
1757 :
1758 0 : static gboolean bd_fs_ext3_check_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
1759 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext3_check' called, but not implemented!");
1760 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1761 : "The function 'bd_fs_ext3_check' called, but not implemented!");
1762 0 : return FALSE;
1763 : }
1764 :
1765 : static gboolean (*_bd_fs_ext3_check) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_ext3_check_stub;
1766 :
1767 : /**
1768 : * bd_fs_ext3_check:
1769 : * @device: the device the file system on which to check
1770 : * @extra: (nullable) (array zero-terminated=1): extra options for the check (right now
1771 : * passed to the 'e2fsck' utility)
1772 : * @error: (out) (optional): place to store error (if any)
1773 : *
1774 : * Returns: whether an ext3 file system on the @device is clean or not
1775 : *
1776 : * Tech category: %BD_FS_TECH_EXT3-%BD_FS_TECH_MODE_CHECK
1777 : */
1778 1 : gboolean bd_fs_ext3_check (const gchar *device, const BDExtraArg **extra, GError **error) {
1779 1 : return _bd_fs_ext3_check (device, extra, error);
1780 : }
1781 :
1782 :
1783 0 : static gboolean bd_fs_ext4_check_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
1784 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext4_check' called, but not implemented!");
1785 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1786 : "The function 'bd_fs_ext4_check' called, but not implemented!");
1787 0 : return FALSE;
1788 : }
1789 :
1790 : static gboolean (*_bd_fs_ext4_check) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_ext4_check_stub;
1791 :
1792 : /**
1793 : * bd_fs_ext4_check:
1794 : * @device: the device the file system on which to check
1795 : * @extra: (nullable) (array zero-terminated=1): extra options for the check (right now
1796 : * passed to the 'e2fsck' utility)
1797 : * @error: (out) (optional): place to store error (if any)
1798 : *
1799 : * Returns: whether an ext4 file system on the @device is clean or not
1800 : *
1801 : * Tech category: %BD_FS_TECH_EXT4-%BD_FS_TECH_MODE_CHECK
1802 : */
1803 4 : gboolean bd_fs_ext4_check (const gchar *device, const BDExtraArg **extra, GError **error) {
1804 4 : return _bd_fs_ext4_check (device, extra, error);
1805 : }
1806 :
1807 :
1808 0 : static gboolean bd_fs_ext2_repair_stub (const gchar *device G_GNUC_UNUSED, gboolean unsafe G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
1809 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext2_repair' called, but not implemented!");
1810 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1811 : "The function 'bd_fs_ext2_repair' called, but not implemented!");
1812 0 : return FALSE;
1813 : }
1814 :
1815 : static gboolean (*_bd_fs_ext2_repair) (const gchar *device, gboolean unsafe, const BDExtraArg **extra, GError **error) = bd_fs_ext2_repair_stub;
1816 :
1817 : /**
1818 : * bd_fs_ext2_repair:
1819 : * @device: the device the file system on which to repair
1820 : * @unsafe: whether to do unsafe operations too
1821 : * @extra: (nullable) (array zero-terminated=1): extra options for the repair (right now
1822 : * passed to the 'e2fsck' utility)
1823 : * @error: (out) (optional): place to store error (if any)
1824 : *
1825 : * Returns: whether an ext2 file system on the @device was successfully repaired
1826 : * (if needed) or not (error is set in that case)
1827 : *
1828 : * Tech category: %BD_FS_TECH_EXT2-%BD_FS_TECH_MODE_REPAIR
1829 : */
1830 3 : gboolean bd_fs_ext2_repair (const gchar *device, gboolean unsafe, const BDExtraArg **extra, GError **error) {
1831 3 : return _bd_fs_ext2_repair (device, unsafe, extra, error);
1832 : }
1833 :
1834 :
1835 0 : static gboolean bd_fs_ext3_repair_stub (const gchar *device G_GNUC_UNUSED, gboolean unsafe G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
1836 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext3_repair' called, but not implemented!");
1837 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1838 : "The function 'bd_fs_ext3_repair' called, but not implemented!");
1839 0 : return FALSE;
1840 : }
1841 :
1842 : static gboolean (*_bd_fs_ext3_repair) (const gchar *device, gboolean unsafe, const BDExtraArg **extra, GError **error) = bd_fs_ext3_repair_stub;
1843 :
1844 : /**
1845 : * bd_fs_ext3_repair:
1846 : * @device: the device the file system on which to repair
1847 : * @unsafe: whether to do unsafe operations too
1848 : * @extra: (nullable) (array zero-terminated=1): extra options for the repair (right now
1849 : * passed to the 'e2fsck' utility)
1850 : * @error: (out) (optional): place to store error (if any)
1851 : *
1852 : * Returns: whether an ext3 file system on the @device was successfully repaired
1853 : * (if needed) or not (error is set in that case)
1854 : *
1855 : * Tech category: %BD_FS_TECH_EXT3-%BD_FS_TECH_MODE_REPAIR
1856 : */
1857 3 : gboolean bd_fs_ext3_repair (const gchar *device, gboolean unsafe, const BDExtraArg **extra, GError **error) {
1858 3 : return _bd_fs_ext3_repair (device, unsafe, extra, error);
1859 : }
1860 :
1861 :
1862 0 : static gboolean bd_fs_ext4_repair_stub (const gchar *device G_GNUC_UNUSED, gboolean unsafe G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
1863 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext4_repair' called, but not implemented!");
1864 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1865 : "The function 'bd_fs_ext4_repair' called, but not implemented!");
1866 0 : return FALSE;
1867 : }
1868 :
1869 : static gboolean (*_bd_fs_ext4_repair) (const gchar *device, gboolean unsafe, const BDExtraArg **extra, GError **error) = bd_fs_ext4_repair_stub;
1870 :
1871 : /**
1872 : * bd_fs_ext4_repair:
1873 : * @device: the device the file system on which to repair
1874 : * @unsafe: whether to do unsafe operations too
1875 : * @extra: (nullable) (array zero-terminated=1): extra options for the repair (right now
1876 : * passed to the 'e2fsck' utility)
1877 : * @error: (out) (optional): place to store error (if any)
1878 : *
1879 : * Returns: whether an ext4 file system on the @device was successfully repaired
1880 : * (if needed) or not (error is set in that case)
1881 : *
1882 : * Tech category: %BD_FS_TECH_EXT4-%BD_FS_TECH_MODE_REPAIR
1883 : */
1884 5 : gboolean bd_fs_ext4_repair (const gchar *device, gboolean unsafe, const BDExtraArg **extra, GError **error) {
1885 5 : return _bd_fs_ext4_repair (device, unsafe, extra, error);
1886 : }
1887 :
1888 :
1889 0 : static gboolean bd_fs_ext2_set_label_stub (const gchar *device G_GNUC_UNUSED, const gchar *label G_GNUC_UNUSED, GError **error) {
1890 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext2_set_label' called, but not implemented!");
1891 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1892 : "The function 'bd_fs_ext2_set_label' called, but not implemented!");
1893 0 : return FALSE;
1894 : }
1895 :
1896 : static gboolean (*_bd_fs_ext2_set_label) (const gchar *device, const gchar *label, GError **error) = bd_fs_ext2_set_label_stub;
1897 :
1898 : /**
1899 : * bd_fs_ext2_set_label:
1900 : * @device: the device the file system on which to set label for
1901 : * @label: label to set
1902 : * @error: (out) (optional): place to store error (if any)
1903 : *
1904 : * Returns: whether the label of ext2 file system on the @device was
1905 : * successfully set or not
1906 : *
1907 : * Tech category: %BD_FS_TECH_EXT2-%BD_FS_TECH_MODE_SET_LABEL
1908 : */
1909 3 : gboolean bd_fs_ext2_set_label (const gchar *device, const gchar *label, GError **error) {
1910 3 : return _bd_fs_ext2_set_label (device, label, error);
1911 : }
1912 :
1913 :
1914 0 : static gboolean bd_fs_ext3_set_label_stub (const gchar *device G_GNUC_UNUSED, const gchar *label G_GNUC_UNUSED, GError **error) {
1915 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext3_set_label' called, but not implemented!");
1916 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1917 : "The function 'bd_fs_ext3_set_label' called, but not implemented!");
1918 0 : return FALSE;
1919 : }
1920 :
1921 : static gboolean (*_bd_fs_ext3_set_label) (const gchar *device, const gchar *label, GError **error) = bd_fs_ext3_set_label_stub;
1922 :
1923 : /**
1924 : * bd_fs_ext3_set_label:
1925 : * @device: the device the file system on which to set label for
1926 : * @label: label to set
1927 : * @error: (out) (optional): place to store error (if any)
1928 : *
1929 : * Returns: whether the label of ext3 file system on the @device was
1930 : * successfully set or not
1931 : *
1932 : * Tech category: %BD_FS_TECH_EXT3-%BD_FS_TECH_MODE_SET_LABEL
1933 : */
1934 3 : gboolean bd_fs_ext3_set_label (const gchar *device, const gchar *label, GError **error) {
1935 3 : return _bd_fs_ext3_set_label (device, label, error);
1936 : }
1937 :
1938 :
1939 0 : static gboolean bd_fs_ext4_set_label_stub (const gchar *device G_GNUC_UNUSED, const gchar *label G_GNUC_UNUSED, GError **error) {
1940 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext4_set_label' called, but not implemented!");
1941 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1942 : "The function 'bd_fs_ext4_set_label' called, but not implemented!");
1943 0 : return FALSE;
1944 : }
1945 :
1946 : static gboolean (*_bd_fs_ext4_set_label) (const gchar *device, const gchar *label, GError **error) = bd_fs_ext4_set_label_stub;
1947 :
1948 : /**
1949 : * bd_fs_ext4_set_label:
1950 : * @device: the device the file system on which to set label for
1951 : * @label: label to set
1952 : * @error: (out) (optional): place to store error (if any)
1953 : *
1954 : * Returns: whether the label of ext4 file system on the @device was
1955 : * successfully set or not
1956 : *
1957 : * Tech category: %BD_FS_TECH_EXT3-%BD_FS_TECH_MODE_SET_LABEL
1958 : */
1959 5 : gboolean bd_fs_ext4_set_label (const gchar *device, const gchar *label, GError **error) {
1960 5 : return _bd_fs_ext4_set_label (device, label, error);
1961 : }
1962 :
1963 :
1964 0 : static gboolean bd_fs_ext2_check_label_stub (const gchar *label G_GNUC_UNUSED, GError **error) {
1965 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext2_check_label' called, but not implemented!");
1966 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1967 : "The function 'bd_fs_ext2_check_label' called, but not implemented!");
1968 0 : return FALSE;
1969 : }
1970 :
1971 : static gboolean (*_bd_fs_ext2_check_label) (const gchar *label, GError **error) = bd_fs_ext2_check_label_stub;
1972 :
1973 : /**
1974 : * bd_fs_ext2_check_label:
1975 : * @label: label to check
1976 : * @error: (out) (optional): place to store error
1977 : *
1978 : * Returns: whether @label is a valid label for the ext2 file system or not
1979 : * (reason is provided in @error)
1980 : *
1981 : * Tech category: always available
1982 : */
1983 8 : gboolean bd_fs_ext2_check_label (const gchar *label, GError **error) {
1984 8 : return _bd_fs_ext2_check_label (label, error);
1985 : }
1986 :
1987 :
1988 0 : static gboolean bd_fs_ext3_check_label_stub (const gchar *label G_GNUC_UNUSED, GError **error) {
1989 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext3_check_label' called, but not implemented!");
1990 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
1991 : "The function 'bd_fs_ext3_check_label' called, but not implemented!");
1992 0 : return FALSE;
1993 : }
1994 :
1995 : static gboolean (*_bd_fs_ext3_check_label) (const gchar *label, GError **error) = bd_fs_ext3_check_label_stub;
1996 :
1997 : /**
1998 : * bd_fs_ext3_check_label:
1999 : * @label: label to check
2000 : * @error: (out) (optional): place to store error (if any)
2001 : *
2002 : * Returns: whether @label is a valid label for the ext3 file system or not
2003 : * (reason is provided in @error)
2004 : *
2005 : * Tech category: always available
2006 : */
2007 2 : gboolean bd_fs_ext3_check_label (const gchar *label, GError **error) {
2008 2 : return _bd_fs_ext3_check_label (label, error);
2009 : }
2010 :
2011 :
2012 0 : static gboolean bd_fs_ext4_check_label_stub (const gchar *label G_GNUC_UNUSED, GError **error) {
2013 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext4_check_label' called, but not implemented!");
2014 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2015 : "The function 'bd_fs_ext4_check_label' called, but not implemented!");
2016 0 : return FALSE;
2017 : }
2018 :
2019 : static gboolean (*_bd_fs_ext4_check_label) (const gchar *label, GError **error) = bd_fs_ext4_check_label_stub;
2020 :
2021 : /**
2022 : * bd_fs_ext4_check_label:
2023 : * @label: label to check
2024 : * @error: (out) (optional): place to store error (if any)
2025 : *
2026 : * Returns: whether @label is a valid label for the ext4 file system or not
2027 : * (reason is provided in @error)
2028 : *
2029 : * Tech category: always available
2030 : */
2031 4 : gboolean bd_fs_ext4_check_label (const gchar *label, GError **error) {
2032 4 : return _bd_fs_ext4_check_label (label, error);
2033 : }
2034 :
2035 :
2036 0 : static gboolean bd_fs_ext2_set_uuid_stub (const gchar *device G_GNUC_UNUSED, const gchar *uuid G_GNUC_UNUSED, GError **error) {
2037 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext2_set_uuid' called, but not implemented!");
2038 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2039 : "The function 'bd_fs_ext2_set_uuid' called, but not implemented!");
2040 0 : return FALSE;
2041 : }
2042 :
2043 : static gboolean (*_bd_fs_ext2_set_uuid) (const gchar *device, const gchar *uuid, GError **error) = bd_fs_ext2_set_uuid_stub;
2044 :
2045 : /**
2046 : * bd_fs_ext2_set_uuid:
2047 : * @device: the device the file system on which to set UUID for
2048 : * @uuid: (nullable): UUID to set %NULL to generate a new one
2049 : * UUID can also be one of "clear", "random" and "time" to clear,
2050 : * generate a new random/time-based UUID
2051 : * @error: (out) (optional): place to store error (if any)
2052 : *
2053 : * Returns: whether the UUID of ext2 file system on the @device was
2054 : * successfully set or not
2055 : *
2056 : * Tech category: %BD_FS_TECH_EXT2-%BD_FS_TECH_MODE_SET_UUID
2057 : */
2058 5 : gboolean bd_fs_ext2_set_uuid (const gchar *device, const gchar *uuid, GError **error) {
2059 5 : return _bd_fs_ext2_set_uuid (device, uuid, error);
2060 : }
2061 :
2062 :
2063 0 : static gboolean bd_fs_ext3_set_uuid_stub (const gchar *device G_GNUC_UNUSED, const gchar *uuid G_GNUC_UNUSED, GError **error) {
2064 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext3_set_uuid' called, but not implemented!");
2065 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2066 : "The function 'bd_fs_ext3_set_uuid' called, but not implemented!");
2067 0 : return FALSE;
2068 : }
2069 :
2070 : static gboolean (*_bd_fs_ext3_set_uuid) (const gchar *device, const gchar *uuid, GError **error) = bd_fs_ext3_set_uuid_stub;
2071 :
2072 : /**
2073 : * bd_fs_ext3_set_uuid:
2074 : * @device: the device the file system on which to set UUID for
2075 : * @uuid: (nullable): UUID to set %NULL to generate a new one
2076 : * UUID can also be one of "clear", "random" and "time" to clear,
2077 : * generate a new random/time-based UUID
2078 : * @error: (out) (optional): place to store error (if any)
2079 : *
2080 : * Returns: whether the UUID of ext3 file system on the @device was
2081 : * successfully set or not
2082 : *
2083 : * Tech category: %BD_FS_TECH_EXT3-%BD_FS_TECH_MODE_SET_UUID
2084 : */
2085 5 : gboolean bd_fs_ext3_set_uuid (const gchar *device, const gchar *uuid, GError **error) {
2086 5 : return _bd_fs_ext3_set_uuid (device, uuid, error);
2087 : }
2088 :
2089 :
2090 0 : static gboolean bd_fs_ext4_set_uuid_stub (const gchar *device G_GNUC_UNUSED, const gchar *uuid G_GNUC_UNUSED, GError **error) {
2091 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext4_set_uuid' called, but not implemented!");
2092 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2093 : "The function 'bd_fs_ext4_set_uuid' called, but not implemented!");
2094 0 : return FALSE;
2095 : }
2096 :
2097 : static gboolean (*_bd_fs_ext4_set_uuid) (const gchar *device, const gchar *uuid, GError **error) = bd_fs_ext4_set_uuid_stub;
2098 :
2099 : /**
2100 : * bd_fs_ext4_set_uuid:
2101 : * @device: the device the file system on which to set UUID for
2102 : * @uuid: (nullable): UUID to set %NULL to generate a new one
2103 : * UUID can also be one of "clear", "random" and "time" to clear,
2104 : * generate a new random/time-based UUID
2105 : * @error: (out) (optional): place to store error (if any)
2106 : *
2107 : * Returns: whether the UUID of ext4 file system on the @device was
2108 : * successfully set or not
2109 : *
2110 : * Tech category: %BD_FS_TECH_EXT4-%BD_FS_TECH_MODE_SET_UUID
2111 : */
2112 7 : gboolean bd_fs_ext4_set_uuid (const gchar *device, const gchar *uuid, GError **error) {
2113 7 : return _bd_fs_ext4_set_uuid (device, uuid, error);
2114 : }
2115 :
2116 :
2117 0 : static gboolean bd_fs_ext2_check_uuid_stub (const gchar *uuid G_GNUC_UNUSED, GError **error) {
2118 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext2_check_uuid' called, but not implemented!");
2119 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2120 : "The function 'bd_fs_ext2_check_uuid' called, but not implemented!");
2121 0 : return FALSE;
2122 : }
2123 :
2124 : static gboolean (*_bd_fs_ext2_check_uuid) (const gchar *uuid, GError **error) = bd_fs_ext2_check_uuid_stub;
2125 :
2126 : /**
2127 : * bd_fs_ext2_check_uuid:
2128 : * @uuid: UUID to check
2129 : * @error: (out) (optional): place to store error
2130 : *
2131 : * Returns: whether @uuid is a valid UUID for the ext2 file system or not
2132 : * (reason is provided in @error)
2133 : *
2134 : * Tech category: always available
2135 : */
2136 2 : gboolean bd_fs_ext2_check_uuid (const gchar *uuid, GError **error) {
2137 2 : return _bd_fs_ext2_check_uuid (uuid, error);
2138 : }
2139 :
2140 :
2141 0 : static gboolean bd_fs_ext3_check_uuid_stub (const gchar *uuid G_GNUC_UNUSED, GError **error) {
2142 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext3_check_uuid' called, but not implemented!");
2143 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2144 : "The function 'bd_fs_ext3_check_uuid' called, but not implemented!");
2145 0 : return FALSE;
2146 : }
2147 :
2148 : static gboolean (*_bd_fs_ext3_check_uuid) (const gchar *uuid, GError **error) = bd_fs_ext3_check_uuid_stub;
2149 :
2150 : /**
2151 : * bd_fs_ext3_check_uuid:
2152 : * @uuid: UUID to check
2153 : * @error: (out) (optional): place to store error
2154 : *
2155 : * Returns: whether @uuid is a valid UUID for the ext3 file system or not
2156 : * (reason is provided in @error)
2157 : *
2158 : * Tech category: always available
2159 : */
2160 2 : gboolean bd_fs_ext3_check_uuid (const gchar *uuid, GError **error) {
2161 2 : return _bd_fs_ext3_check_uuid (uuid, error);
2162 : }
2163 :
2164 :
2165 0 : static gboolean bd_fs_ext4_check_uuid_stub (const gchar *uuid G_GNUC_UNUSED, GError **error) {
2166 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext4_check_uuid' called, but not implemented!");
2167 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2168 : "The function 'bd_fs_ext4_check_uuid' called, but not implemented!");
2169 0 : return FALSE;
2170 : }
2171 :
2172 : static gboolean (*_bd_fs_ext4_check_uuid) (const gchar *uuid, GError **error) = bd_fs_ext4_check_uuid_stub;
2173 :
2174 : /**
2175 : * bd_fs_ext4_check_uuid:
2176 : * @uuid: UUID to check
2177 : * @error: (out) (optional): place to store error
2178 : *
2179 : * Returns: whether @uuid is a valid UUID for the ext4 file system or not
2180 : * (reason is provided in @error)
2181 : *
2182 : * Tech category: always available
2183 : */
2184 3 : gboolean bd_fs_ext4_check_uuid (const gchar *uuid, GError **error) {
2185 3 : return _bd_fs_ext4_check_uuid (uuid, error);
2186 : }
2187 :
2188 :
2189 0 : static BDFSExt2Info* bd_fs_ext2_get_info_stub (const gchar *device G_GNUC_UNUSED, GError **error) {
2190 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext2_get_info' called, but not implemented!");
2191 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2192 : "The function 'bd_fs_ext2_get_info' called, but not implemented!");
2193 0 : return NULL;
2194 : }
2195 :
2196 : static BDFSExt2Info* (*_bd_fs_ext2_get_info) (const gchar *device, GError **error) = bd_fs_ext2_get_info_stub;
2197 :
2198 : /**
2199 : * bd_fs_ext2_get_info:
2200 : * @device: the device the file system of which to get info for
2201 : * @error: (out) (optional): place to store error (if any)
2202 : *
2203 : * Returns: (transfer full): information about the file system on @device or
2204 : * %NULL in case of error
2205 : *
2206 : * Tech category: %BD_FS_TECH_EXT2-%BD_FS_TECH_MODE_QUERY
2207 : */
2208 19 : BDFSExt2Info* bd_fs_ext2_get_info (const gchar *device, GError **error) {
2209 19 : return _bd_fs_ext2_get_info (device, error);
2210 : }
2211 :
2212 :
2213 0 : static BDFSExt3Info* bd_fs_ext3_get_info_stub (const gchar *device G_GNUC_UNUSED, GError **error) {
2214 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext3_get_info' called, but not implemented!");
2215 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2216 : "The function 'bd_fs_ext3_get_info' called, but not implemented!");
2217 0 : return NULL;
2218 : }
2219 :
2220 : static BDFSExt3Info* (*_bd_fs_ext3_get_info) (const gchar *device, GError **error) = bd_fs_ext3_get_info_stub;
2221 :
2222 : /**
2223 : * bd_fs_ext3_get_info:
2224 : * @device: the device the file system of which to get info for
2225 : * @error: (out) (optional): place to store error (if any)
2226 : *
2227 : * Returns: (transfer full): information about the file system on @device or
2228 : * %NULL in case of error
2229 : *
2230 : * Tech category: %BD_FS_TECH_EXT3-%BD_FS_TECH_MODE_QUERY
2231 : */
2232 18 : BDFSExt3Info* bd_fs_ext3_get_info (const gchar *device, GError **error) {
2233 18 : return _bd_fs_ext3_get_info (device, error);
2234 : }
2235 :
2236 :
2237 0 : static BDFSExt4Info* bd_fs_ext4_get_info_stub (const gchar *device G_GNUC_UNUSED, GError **error) {
2238 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext4_get_info' called, but not implemented!");
2239 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2240 : "The function 'bd_fs_ext4_get_info' called, but not implemented!");
2241 0 : return NULL;
2242 : }
2243 :
2244 : static BDFSExt4Info* (*_bd_fs_ext4_get_info) (const gchar *device, GError **error) = bd_fs_ext4_get_info_stub;
2245 :
2246 : /**
2247 : * bd_fs_ext4_get_info:
2248 : * @device: the device the file system of which to get info for
2249 : * @error: (out) (optional): place to store error (if any)
2250 : *
2251 : * Returns: (transfer full): information about the file system on @device or
2252 : * %NULL in case of error
2253 : *
2254 : * Tech category: %BD_FS_TECH_EXT3-%BD_FS_TECH_MODE_QUERY
2255 : */
2256 45 : BDFSExt4Info* bd_fs_ext4_get_info (const gchar *device, GError **error) {
2257 45 : return _bd_fs_ext4_get_info (device, error);
2258 : }
2259 :
2260 :
2261 0 : static gboolean bd_fs_ext2_resize_stub (const gchar *device G_GNUC_UNUSED, guint64 new_size G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
2262 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext2_resize' called, but not implemented!");
2263 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2264 : "The function 'bd_fs_ext2_resize' called, but not implemented!");
2265 0 : return FALSE;
2266 : }
2267 :
2268 : static gboolean (*_bd_fs_ext2_resize) (const gchar *device, guint64 new_size, const BDExtraArg **extra, GError **error) = bd_fs_ext2_resize_stub;
2269 :
2270 : /**
2271 : * bd_fs_ext2_resize:
2272 : * @device: the device the file system of which to resize
2273 : * @new_size: new requested size for the file system (if 0, the file system is
2274 : * adapted to the underlying block device)
2275 : * @extra: (nullable) (array zero-terminated=1): extra options for the resize (right now
2276 : * passed to the 'resize2fs' utility)
2277 : * @error: (out) (optional): place to store error (if any)
2278 : *
2279 : * Returns: whether the file system on @device was successfully resized or not
2280 : *
2281 : * Tech category: %BD_FS_TECH_EXT2-%BD_FS_TECH_MODE_RESIZE
2282 : */
2283 5 : gboolean bd_fs_ext2_resize (const gchar *device, guint64 new_size, const BDExtraArg **extra, GError **error) {
2284 5 : return _bd_fs_ext2_resize (device, new_size, extra, error);
2285 : }
2286 :
2287 :
2288 0 : static gboolean bd_fs_ext3_resize_stub (const gchar *device G_GNUC_UNUSED, guint64 new_size G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
2289 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext3_resize' called, but not implemented!");
2290 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2291 : "The function 'bd_fs_ext3_resize' called, but not implemented!");
2292 0 : return FALSE;
2293 : }
2294 :
2295 : static gboolean (*_bd_fs_ext3_resize) (const gchar *device, guint64 new_size, const BDExtraArg **extra, GError **error) = bd_fs_ext3_resize_stub;
2296 :
2297 : /**
2298 : * bd_fs_ext3_resize:
2299 : * @device: the device the file system of which to resize
2300 : * @new_size: new requested size for the file system (if 0, the file system is
2301 : * adapted to the underlying block device)
2302 : * @extra: (nullable) (array zero-terminated=1): extra options for the resize (right now
2303 : * passed to the 'resize2fs' utility)
2304 : * @error: (out) (optional): place to store error (if any)
2305 : *
2306 : * Returns: whether the file system on @device was successfully resized or not
2307 : *
2308 : * Tech category: %BD_FS_TECH_EXT3-%BD_FS_TECH_MODE_RESIZE
2309 : */
2310 5 : gboolean bd_fs_ext3_resize (const gchar *device, guint64 new_size, const BDExtraArg **extra, GError **error) {
2311 5 : return _bd_fs_ext3_resize (device, new_size, extra, error);
2312 : }
2313 :
2314 :
2315 0 : static gboolean bd_fs_ext4_resize_stub (const gchar *device G_GNUC_UNUSED, guint64 new_size G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
2316 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext4_resize' called, but not implemented!");
2317 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2318 : "The function 'bd_fs_ext4_resize' called, but not implemented!");
2319 0 : return FALSE;
2320 : }
2321 :
2322 : static gboolean (*_bd_fs_ext4_resize) (const gchar *device, guint64 new_size, const BDExtraArg **extra, GError **error) = bd_fs_ext4_resize_stub;
2323 :
2324 : /**
2325 : * bd_fs_ext4_resize:
2326 : * @device: the device the file system of which to resize
2327 : * @new_size: new requested size for the file system (if 0, the file system is
2328 : * adapted to the underlying block device)
2329 : * @extra: (nullable) (array zero-terminated=1): extra options for the resize (right now
2330 : * passed to the 'resize2fs' utility)
2331 : * @error: (out) (optional): place to store error (if any)
2332 : *
2333 : * Returns: whether the file system on @device was successfully resized or not
2334 : *
2335 : * Tech category: %BD_FS_TECH_EXT4-%BD_FS_TECH_MODE_RESIZE
2336 : */
2337 11 : gboolean bd_fs_ext4_resize (const gchar *device, guint64 new_size, const BDExtraArg **extra, GError **error) {
2338 11 : return _bd_fs_ext4_resize (device, new_size, extra, error);
2339 : }
2340 :
2341 :
2342 0 : static guint64 bd_fs_ext2_get_min_size_stub (const gchar *device G_GNUC_UNUSED, GError **error) {
2343 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext2_get_min_size' called, but not implemented!");
2344 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2345 : "The function 'bd_fs_ext2_get_min_size' called, but not implemented!");
2346 0 : return 0;
2347 : }
2348 :
2349 : static guint64 (*_bd_fs_ext2_get_min_size) (const gchar *device, GError **error) = bd_fs_ext2_get_min_size_stub;
2350 :
2351 : /**
2352 : * bd_fs_ext2_get_min_size:
2353 : * @device: the device containing the file system to get min size for
2354 : * @error: (out) (optional): place to store error (if any)
2355 : *
2356 : * Returns: smallest shrunken filesystem size as reported by resize2fs
2357 : * in case of error 0 is returned and @error is set
2358 : *
2359 : * Tech category: %BD_FS_TECH_EXT2-%BD_FS_TECH_MODE_RESIZE
2360 : */
2361 4 : guint64 bd_fs_ext2_get_min_size (const gchar *device, GError **error) {
2362 4 : return _bd_fs_ext2_get_min_size (device, error);
2363 : }
2364 :
2365 :
2366 0 : static guint64 bd_fs_ext3_get_min_size_stub (const gchar *device G_GNUC_UNUSED, GError **error) {
2367 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext3_get_min_size' called, but not implemented!");
2368 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2369 : "The function 'bd_fs_ext3_get_min_size' called, but not implemented!");
2370 0 : return 0;
2371 : }
2372 :
2373 : static guint64 (*_bd_fs_ext3_get_min_size) (const gchar *device, GError **error) = bd_fs_ext3_get_min_size_stub;
2374 :
2375 : /**
2376 : * bd_fs_ext3_get_min_size:
2377 : * @device: the device containing the file system to get min size for
2378 : * @error: (out) (optional): place to store error (if any)
2379 : *
2380 : * Returns: smallest shrunken filesystem size as reported by resize2fs
2381 : * in case of error 0 is returned and @error is set
2382 : *
2383 : * Tech category: %BD_FS_TECH_EXT3-%BD_FS_TECH_MODE_RESIZE
2384 : */
2385 1 : guint64 bd_fs_ext3_get_min_size (const gchar *device, GError **error) {
2386 1 : return _bd_fs_ext3_get_min_size (device, error);
2387 : }
2388 :
2389 :
2390 0 : static guint64 bd_fs_ext4_get_min_size_stub (const gchar *device G_GNUC_UNUSED, GError **error) {
2391 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ext4_get_min_size' called, but not implemented!");
2392 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2393 : "The function 'bd_fs_ext4_get_min_size' called, but not implemented!");
2394 0 : return 0;
2395 : }
2396 :
2397 : static guint64 (*_bd_fs_ext4_get_min_size) (const gchar *device, GError **error) = bd_fs_ext4_get_min_size_stub;
2398 :
2399 : /**
2400 : * bd_fs_ext4_get_min_size:
2401 : * @device: the device containing the file system to get min size for
2402 : * @error: (out) (optional): place to store error (if any)
2403 : *
2404 : * Returns: smallest shrunken filesystem size as reported by resize2fs
2405 : * in case of error 0 is returned and @error is set
2406 : *
2407 : * Tech category: %BD_FS_TECH_EXT4-%BD_FS_TECH_MODE_RESIZE
2408 : */
2409 1 : guint64 bd_fs_ext4_get_min_size (const gchar *device, GError **error) {
2410 1 : return _bd_fs_ext4_get_min_size (device, error);
2411 : }
2412 :
2413 :
2414 0 : static gboolean bd_fs_xfs_mkfs_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
2415 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_xfs_mkfs' called, but not implemented!");
2416 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2417 : "The function 'bd_fs_xfs_mkfs' called, but not implemented!");
2418 0 : return FALSE;
2419 : }
2420 :
2421 : static gboolean (*_bd_fs_xfs_mkfs) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_xfs_mkfs_stub;
2422 :
2423 : /**
2424 : * bd_fs_xfs_mkfs:
2425 : * @device: the device to create a new xfs fs on
2426 : * @extra: (nullable) (array zero-terminated=1): extra options for the creation (right now
2427 : * passed to the 'mkfs.xfs' utility)
2428 : * @error: (out) (optional): place to store error (if any)
2429 : *
2430 : * Returns: whether a new xfs fs was successfully created on @device or not
2431 : *
2432 : * Tech category: %BD_FS_TECH_XFS-%BD_FS_TECH_MODE_MKFS
2433 : */
2434 24 : gboolean bd_fs_xfs_mkfs (const gchar *device, const BDExtraArg **extra, GError **error) {
2435 24 : return _bd_fs_xfs_mkfs (device, extra, error);
2436 : }
2437 :
2438 :
2439 0 : static gboolean bd_fs_xfs_check_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
2440 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_xfs_check' called, but not implemented!");
2441 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2442 : "The function 'bd_fs_xfs_check' called, but not implemented!");
2443 0 : return FALSE;
2444 : }
2445 :
2446 : static gboolean (*_bd_fs_xfs_check) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_xfs_check_stub;
2447 :
2448 : /**
2449 : * bd_fs_xfs_check:
2450 : * @device: the device containing the file system to check
2451 : * @extra: (nullable) (array zero-terminated=1): extra options for the repair (right now
2452 : * passed to the 'xfs_repair' utility)
2453 : * @error: (out) (optional): place to store error (if any)
2454 : *
2455 : * Returns: whether an xfs file system on the @device is clean or not
2456 : *
2457 : * Note: If the file system is mounted RW, it will always be reported as not
2458 : * clean!
2459 : *
2460 : * Tech category: %BD_FS_TECH_XFS-%BD_FS_TECH_MODE_CHECK
2461 : */
2462 5 : gboolean bd_fs_xfs_check (const gchar *device, const BDExtraArg **extra, GError **error) {
2463 5 : return _bd_fs_xfs_check (device, extra, error);
2464 : }
2465 :
2466 :
2467 0 : static gboolean bd_fs_xfs_repair_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
2468 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_xfs_repair' called, but not implemented!");
2469 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2470 : "The function 'bd_fs_xfs_repair' called, but not implemented!");
2471 0 : return FALSE;
2472 : }
2473 :
2474 : static gboolean (*_bd_fs_xfs_repair) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_xfs_repair_stub;
2475 :
2476 : /**
2477 : * bd_fs_xfs_repair:
2478 : * @device: the device containing the file system to repair
2479 : * @extra: (nullable) (array zero-terminated=1): extra options for the repair (right now
2480 : * passed to the 'xfs_repair' utility)
2481 : * @error: (out) (optional): place to store error (if any)
2482 : *
2483 : * Returns: whether an xfs file system on the @device was successfully repaired
2484 : * (if needed) or not (error is set in that case)
2485 : *
2486 : * Tech category: %BD_FS_TECH_XFS-%BD_FS_TECH_MODE_REPAIR
2487 : */
2488 5 : gboolean bd_fs_xfs_repair (const gchar *device, const BDExtraArg **extra, GError **error) {
2489 5 : return _bd_fs_xfs_repair (device, extra, error);
2490 : }
2491 :
2492 :
2493 0 : static gboolean bd_fs_xfs_set_label_stub (const gchar *device G_GNUC_UNUSED, const gchar *label G_GNUC_UNUSED, GError **error) {
2494 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_xfs_set_label' called, but not implemented!");
2495 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2496 : "The function 'bd_fs_xfs_set_label' called, but not implemented!");
2497 0 : return FALSE;
2498 : }
2499 :
2500 : static gboolean (*_bd_fs_xfs_set_label) (const gchar *device, const gchar *label, GError **error) = bd_fs_xfs_set_label_stub;
2501 :
2502 : /**
2503 : * bd_fs_xfs_set_label:
2504 : * @device: the device containing the file system to set label for
2505 : * @label: label to set
2506 : * @error: (out) (optional): place to store error (if any)
2507 : *
2508 : * Returns: whether the label of xfs file system on the @device was
2509 : * successfully set or not
2510 : *
2511 : * Tech category: %BD_FS_TECH_XFS-%BD_FS_TECH_MODE_SET_LABEL
2512 : */
2513 5 : gboolean bd_fs_xfs_set_label (const gchar *device, const gchar *label, GError **error) {
2514 5 : return _bd_fs_xfs_set_label (device, label, error);
2515 : }
2516 :
2517 :
2518 0 : static gboolean bd_fs_xfs_check_label_stub (const gchar *label G_GNUC_UNUSED, GError **error) {
2519 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_xfs_check_label' called, but not implemented!");
2520 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2521 : "The function 'bd_fs_xfs_check_label' called, but not implemented!");
2522 0 : return FALSE;
2523 : }
2524 :
2525 : static gboolean (*_bd_fs_xfs_check_label) (const gchar *label, GError **error) = bd_fs_xfs_check_label_stub;
2526 :
2527 : /**
2528 : * bd_fs_xfs_check_label:
2529 : * @label: label to check
2530 : * @error: (out) (optional): place to store error
2531 : *
2532 : * Returns: whether @label is a valid label for the xfs file system or not
2533 : * (reason is provided in @error)
2534 : *
2535 : * Tech category: always available
2536 : */
2537 5 : gboolean bd_fs_xfs_check_label (const gchar *label, GError **error) {
2538 5 : return _bd_fs_xfs_check_label (label, error);
2539 : }
2540 :
2541 :
2542 0 : static gboolean bd_fs_xfs_set_uuid_stub (const gchar *device G_GNUC_UNUSED, const gchar *uuid G_GNUC_UNUSED, GError **error) {
2543 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_xfs_set_uuid' called, but not implemented!");
2544 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2545 : "The function 'bd_fs_xfs_set_uuid' called, but not implemented!");
2546 0 : return FALSE;
2547 : }
2548 :
2549 : static gboolean (*_bd_fs_xfs_set_uuid) (const gchar *device, const gchar *uuid, GError **error) = bd_fs_xfs_set_uuid_stub;
2550 :
2551 : /**
2552 : * bd_fs_xfs_set_uuid:
2553 : * @device: the device containing the file system to set uuid for
2554 : * @uuid: (nullable): UUID to set %NULL to generate a new one
2555 : * UUID can also be one of "nil" and "generate" to clear or
2556 : * generate a new UUID
2557 : * @error: (out) (optional): place to store error (if any)
2558 : *
2559 : * Returns: whether the UUID of xfs file system on the @device was
2560 : * successfully set or not
2561 : *
2562 : * Tech category: %BD_FS_TECH_XFS-%BD_FS_TECH_MODE_SET_UUID
2563 : */
2564 6 : gboolean bd_fs_xfs_set_uuid (const gchar *device, const gchar *uuid, GError **error) {
2565 6 : return _bd_fs_xfs_set_uuid (device, uuid, error);
2566 : }
2567 :
2568 :
2569 0 : static BDFSXfsInfo* bd_fs_xfs_get_info_stub (const gchar *device G_GNUC_UNUSED, GError **error) {
2570 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_xfs_get_info' called, but not implemented!");
2571 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2572 : "The function 'bd_fs_xfs_get_info' called, but not implemented!");
2573 0 : return NULL;
2574 : }
2575 :
2576 : static BDFSXfsInfo* (*_bd_fs_xfs_get_info) (const gchar *device, GError **error) = bd_fs_xfs_get_info_stub;
2577 :
2578 : /**
2579 : * bd_fs_xfs_get_info:
2580 : * @device: the device containing the file system to get info for (device must
2581 : be mounted, trying to get info for an unmounted device will result
2582 : in an error)
2583 : * @error: (out) (optional): place to store error (if any)
2584 : *
2585 : * Returns: (transfer full): information about the file system on @device or
2586 : * %NULL in case of error
2587 : *
2588 : * Tech category: %BD_FS_TECH_XFS-%BD_FS_TECH_MODE_QUERY
2589 : */
2590 41 : BDFSXfsInfo* bd_fs_xfs_get_info (const gchar *device, GError **error) {
2591 41 : return _bd_fs_xfs_get_info (device, error);
2592 : }
2593 :
2594 :
2595 0 : static gboolean bd_fs_xfs_resize_stub (const gchar *mpoint G_GNUC_UNUSED, guint64 new_size G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
2596 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_xfs_resize' called, but not implemented!");
2597 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2598 : "The function 'bd_fs_xfs_resize' called, but not implemented!");
2599 0 : return FALSE;
2600 : }
2601 :
2602 : static gboolean (*_bd_fs_xfs_resize) (const gchar *mpoint, guint64 new_size, const BDExtraArg **extra, GError **error) = bd_fs_xfs_resize_stub;
2603 :
2604 : /**
2605 : * bd_fs_xfs_resize:
2606 : * @mpoint: the mount point of the file system to resize
2607 : * @new_size: new requested size for the file system *in file system blocks* (see bd_fs_xfs_get_info())
2608 : * (if 0, the file system is adapted to the underlying block device)
2609 : * @extra: (nullable) (array zero-terminated=1): extra options for the resize (right now
2610 : * passed to the 'xfs_growfs' utility)
2611 : * @error: (out) (optional): place to store error (if any)
2612 : *
2613 : * Returns: whether the file system mounted on @mpoint was successfully resized or not
2614 : *
2615 : * Tech category: %BD_FS_TECH_XFS-%BD_FS_TECH_MODE_RESIZE
2616 : */
2617 16 : gboolean bd_fs_xfs_resize (const gchar *mpoint, guint64 new_size, const BDExtraArg **extra, GError **error) {
2618 16 : return _bd_fs_xfs_resize (mpoint, new_size, extra, error);
2619 : }
2620 :
2621 :
2622 0 : static gboolean bd_fs_vfat_mkfs_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
2623 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_vfat_mkfs' called, but not implemented!");
2624 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2625 : "The function 'bd_fs_vfat_mkfs' called, but not implemented!");
2626 0 : return FALSE;
2627 : }
2628 :
2629 : static gboolean (*_bd_fs_vfat_mkfs) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_vfat_mkfs_stub;
2630 :
2631 : /**
2632 : * bd_fs_vfat_mkfs:
2633 : * @device: the device to create a new vfat fs on
2634 : * @extra: (nullable) (array zero-terminated=1): extra options for the creation (right now
2635 : * passed to the 'mkfs.vfat' utility)
2636 : * @error: (out) (optional): place to store error (if any)
2637 : *
2638 : * Please remember that FAT labels should always be uppercase.
2639 : *
2640 : * Returns: whether a new vfat fs was successfully created on @device or not
2641 : *
2642 : * Tech category: %BD_FS_TECH_VFAT-%BD_FS_TECH_MODE_MKFS
2643 : */
2644 21 : gboolean bd_fs_vfat_mkfs (const gchar *device, const BDExtraArg **extra, GError **error) {
2645 21 : return _bd_fs_vfat_mkfs (device, extra, error);
2646 : }
2647 :
2648 :
2649 0 : static gboolean bd_fs_vfat_check_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
2650 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_vfat_check' called, but not implemented!");
2651 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2652 : "The function 'bd_fs_vfat_check' called, but not implemented!");
2653 0 : return FALSE;
2654 : }
2655 :
2656 : static gboolean (*_bd_fs_vfat_check) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_vfat_check_stub;
2657 :
2658 : /**
2659 : * bd_fs_vfat_check:
2660 : * @device: the device containing the file system to check
2661 : * @extra: (nullable) (array zero-terminated=1): extra options for the repair (right now
2662 : * passed to the 'fsck.vfat' utility)
2663 : * @error: (out) (optional): place to store error (if any)
2664 : *
2665 : * Returns: whether an vfat file system on the @device is clean or not
2666 : *
2667 : * Tech category: %BD_FS_TECH_VFAT-%BD_FS_TECH_MODE_CHECK
2668 : */
2669 2 : gboolean bd_fs_vfat_check (const gchar *device, const BDExtraArg **extra, GError **error) {
2670 2 : return _bd_fs_vfat_check (device, extra, error);
2671 : }
2672 :
2673 :
2674 0 : static gboolean bd_fs_vfat_repair_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
2675 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_vfat_repair' called, but not implemented!");
2676 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2677 : "The function 'bd_fs_vfat_repair' called, but not implemented!");
2678 0 : return FALSE;
2679 : }
2680 :
2681 : static gboolean (*_bd_fs_vfat_repair) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_vfat_repair_stub;
2682 :
2683 : /**
2684 : * bd_fs_vfat_repair:
2685 : * @device: the device containing the file system to repair
2686 : * @extra: (nullable) (array zero-terminated=1): extra options for the repair (right now
2687 : * passed to the 'fsck.vfat' utility)
2688 : * @error: (out) (optional): place to store error (if any)
2689 : *
2690 : * Returns: whether an vfat file system on the @device was successfully repaired
2691 : * (if needed) or not (error is set in that case)
2692 : *
2693 : * Tech category: %BD_FS_TECH_VFAT-%BD_FS_TECH_MODE_REPAIR
2694 : */
2695 1 : gboolean bd_fs_vfat_repair (const gchar *device, const BDExtraArg **extra, GError **error) {
2696 1 : return _bd_fs_vfat_repair (device, extra, error);
2697 : }
2698 :
2699 :
2700 0 : static gboolean bd_fs_vfat_set_label_stub (const gchar *device G_GNUC_UNUSED, const gchar *label G_GNUC_UNUSED, GError **error) {
2701 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_vfat_set_label' called, but not implemented!");
2702 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2703 : "The function 'bd_fs_vfat_set_label' called, but not implemented!");
2704 0 : return FALSE;
2705 : }
2706 :
2707 : static gboolean (*_bd_fs_vfat_set_label) (const gchar *device, const gchar *label, GError **error) = bd_fs_vfat_set_label_stub;
2708 :
2709 : /**
2710 : * bd_fs_vfat_set_label:
2711 : * @device: the device containing the file system to set label for
2712 : * @label: label to set
2713 : * @error: (out) (optional): place to store error (if any)
2714 : *
2715 : * Returns: whether the label of vfat file system on the @device was
2716 : * successfully set or not
2717 : *
2718 : * Tech category: %BD_FS_TECH_VFAT-%BD_FS_TECH_MODE_SET_LABEL
2719 : */
2720 5 : gboolean bd_fs_vfat_set_label (const gchar *device, const gchar *label, GError **error) {
2721 5 : return _bd_fs_vfat_set_label (device, label, error);
2722 : }
2723 :
2724 :
2725 0 : static gboolean bd_fs_vfat_check_label_stub (const gchar *label G_GNUC_UNUSED, GError **error) {
2726 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_vfat_check_label' called, but not implemented!");
2727 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2728 : "The function 'bd_fs_vfat_check_label' called, but not implemented!");
2729 0 : return FALSE;
2730 : }
2731 :
2732 : static gboolean (*_bd_fs_vfat_check_label) (const gchar *label, GError **error) = bd_fs_vfat_check_label_stub;
2733 :
2734 : /**
2735 : * bd_fs_vfat_check_label:
2736 : * @label: label to check
2737 : * @error: (out) (optional): place to store error
2738 : *
2739 : * Returns: whether @label is a valid label for the vfat file system or not
2740 : * (reason is provided in @error)
2741 : *
2742 : * Tech category: always available
2743 : */
2744 4 : gboolean bd_fs_vfat_check_label (const gchar *label, GError **error) {
2745 4 : return _bd_fs_vfat_check_label (label, error);
2746 : }
2747 :
2748 :
2749 0 : static gboolean bd_fs_vfat_set_uuid_stub (const gchar *device G_GNUC_UNUSED, const gchar *uuid G_GNUC_UNUSED, GError **error) {
2750 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_vfat_set_uuid' called, but not implemented!");
2751 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2752 : "The function 'bd_fs_vfat_set_uuid' called, but not implemented!");
2753 0 : return FALSE;
2754 : }
2755 :
2756 : static gboolean (*_bd_fs_vfat_set_uuid) (const gchar *device, const gchar *uuid, GError **error) = bd_fs_vfat_set_uuid_stub;
2757 :
2758 : /**
2759 : * bd_fs_vfat_set_uuid:
2760 : * @device: the device containing the file system to set uuid for
2761 : * @uuid: (nullable): volume ID to set or %NULL to generate a new one
2762 : * @error: (out) (optional): place to store error (if any)
2763 : *
2764 : * Returns: whether the volume ID of vfat file system on the @device was
2765 : * successfully set or not
2766 : *
2767 : * Tech category: %BD_FS_TECH_VFAT-%BD_FS_TECH_MODE_SET_UUID
2768 : */
2769 5 : gboolean bd_fs_vfat_set_uuid (const gchar *device, const gchar *uuid, GError **error) {
2770 5 : return _bd_fs_vfat_set_uuid (device, uuid, error);
2771 : }
2772 :
2773 :
2774 0 : static gboolean bd_fs_vfat_check_uuid_stub (const gchar *uuid G_GNUC_UNUSED, GError **error) {
2775 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_vfat_check_uuid' called, but not implemented!");
2776 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2777 : "The function 'bd_fs_vfat_check_uuid' called, but not implemented!");
2778 0 : return FALSE;
2779 : }
2780 :
2781 : static gboolean (*_bd_fs_vfat_check_uuid) (const gchar *uuid, GError **error) = bd_fs_vfat_check_uuid_stub;
2782 :
2783 : /**
2784 : * bd_fs_vfat_check_uuid:
2785 : * @uuid: UUID to check
2786 : * @error: (out) (optional): place to store error
2787 : *
2788 : * Returns: whether @uuid is a valid UUID for the vfat file system or not
2789 : * (reason is provided in @error)
2790 : *
2791 : * Tech category: always available
2792 : */
2793 7 : gboolean bd_fs_vfat_check_uuid (const gchar *uuid, GError **error) {
2794 7 : return _bd_fs_vfat_check_uuid (uuid, error);
2795 : }
2796 :
2797 :
2798 0 : static BDFSVfatInfo* bd_fs_vfat_get_info_stub (const gchar *device G_GNUC_UNUSED, GError **error) {
2799 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_vfat_get_info' called, but not implemented!");
2800 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2801 : "The function 'bd_fs_vfat_get_info' called, but not implemented!");
2802 0 : return NULL;
2803 : }
2804 :
2805 : static BDFSVfatInfo* (*_bd_fs_vfat_get_info) (const gchar *device, GError **error) = bd_fs_vfat_get_info_stub;
2806 :
2807 : /**
2808 : * bd_fs_vfat_get_info:
2809 : * @device: the device containing the file system to get info for
2810 : * @error: (out) (optional): place to store error (if any)
2811 : *
2812 : * Returns: (transfer full): information about the file system on @device or
2813 : * %NULL in case of error
2814 : *
2815 : * Tech category: %BD_FS_TECH_VFAT-%BD_FS_TECH_MODE_QUERY
2816 : */
2817 19 : BDFSVfatInfo* bd_fs_vfat_get_info (const gchar *device, GError **error) {
2818 19 : return _bd_fs_vfat_get_info (device, error);
2819 : }
2820 :
2821 :
2822 0 : static gboolean bd_fs_vfat_resize_stub (const gchar *device G_GNUC_UNUSED, guint64 new_size G_GNUC_UNUSED, GError **error) {
2823 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_vfat_resize' called, but not implemented!");
2824 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2825 : "The function 'bd_fs_vfat_resize' called, but not implemented!");
2826 0 : return FALSE;
2827 : }
2828 :
2829 : static gboolean (*_bd_fs_vfat_resize) (const gchar *device, guint64 new_size, GError **error) = bd_fs_vfat_resize_stub;
2830 :
2831 : /**
2832 : * bd_fs_vfat_resize:
2833 : * @device: the device the file system of which to resize
2834 : * @new_size: new requested size for the file system (if 0, the file system is
2835 : * adapted to the underlying block device)
2836 : * @error: (out) (optional): place to store error (if any)
2837 : *
2838 : * Returns: whether the file system on @device was successfully resized or not
2839 : *
2840 : * Tech category: %BD_FS_TECH_VFAT-%BD_FS_TECH_MODE_RESIZE
2841 : */
2842 6 : gboolean bd_fs_vfat_resize (const gchar *device, guint64 new_size, GError **error) {
2843 6 : return _bd_fs_vfat_resize (device, new_size, error);
2844 : }
2845 :
2846 :
2847 0 : static gboolean bd_fs_ntfs_mkfs_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
2848 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ntfs_mkfs' called, but not implemented!");
2849 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2850 : "The function 'bd_fs_ntfs_mkfs' called, but not implemented!");
2851 0 : return FALSE;
2852 : }
2853 :
2854 : static gboolean (*_bd_fs_ntfs_mkfs) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_ntfs_mkfs_stub;
2855 :
2856 : /**
2857 : * bd_fs_ntfs_mkfs:
2858 : * @device: the device to create a new ntfs fs on
2859 : * @extra: (nullable) (array zero-terminated=1): extra options for the creation (right now
2860 : * passed to the 'mkntfs' utility)
2861 : * @error: (out) (optional): place to store error (if any)
2862 : *
2863 : * Returns: whether a new NTFS fs was successfully created on @device or not
2864 : *
2865 : * Tech category: %BD_FS_TECH_NTFS-%BD_FS_TECH_MODE_MKFS
2866 : */
2867 18 : gboolean bd_fs_ntfs_mkfs (const gchar *device, const BDExtraArg **extra, GError **error) {
2868 18 : return _bd_fs_ntfs_mkfs (device, extra, error);
2869 : }
2870 :
2871 :
2872 0 : static gboolean bd_fs_ntfs_check_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
2873 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ntfs_check' called, but not implemented!");
2874 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2875 : "The function 'bd_fs_ntfs_check' called, but not implemented!");
2876 0 : return FALSE;
2877 : }
2878 :
2879 : static gboolean (*_bd_fs_ntfs_check) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_ntfs_check_stub;
2880 :
2881 : /**
2882 : * bd_fs_ntfs_check:
2883 : * @device: the device containing the file system to check
2884 : * @extra: (nullable) (array zero-terminated=1): extra options for the repair (right now
2885 : * passed to the 'ntfsfix' utility)
2886 : * @error: (out) (optional): place to store error (if any)
2887 : *
2888 : * Returns: whether an ntfs file system on the @device is clean or not
2889 : *
2890 : * Tech category: %BD_FS_TECH_NTFS-%BD_FS_TECH_MODE_CHECK
2891 : */
2892 2 : gboolean bd_fs_ntfs_check (const gchar *device, const BDExtraArg **extra, GError **error) {
2893 2 : return _bd_fs_ntfs_check (device, extra, error);
2894 : }
2895 :
2896 :
2897 0 : static gboolean bd_fs_ntfs_repair_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
2898 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ntfs_repair' called, but not implemented!");
2899 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2900 : "The function 'bd_fs_ntfs_repair' called, but not implemented!");
2901 0 : return FALSE;
2902 : }
2903 :
2904 : static gboolean (*_bd_fs_ntfs_repair) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_ntfs_repair_stub;
2905 :
2906 : /**
2907 : * bd_fs_ntfs_repair:
2908 : * @device: the device containing the file system to repair
2909 : * @extra: (nullable) (array zero-terminated=1): extra options for the repair (right now
2910 : * passed to the 'ntfsfix' utility)
2911 : * @error: (out) (optional): place to store error (if any)
2912 : *
2913 : * Returns: whether an NTFS file system on the @device was successfully repaired
2914 : * (if needed) or not (error is set in that case)
2915 : *
2916 : * Tech category: %BD_FS_TECH_NTFS-%BD_FS_TECH_MODE_REPAIR
2917 : */
2918 9 : gboolean bd_fs_ntfs_repair (const gchar *device, const BDExtraArg **extra, GError **error) {
2919 9 : return _bd_fs_ntfs_repair (device, extra, error);
2920 : }
2921 :
2922 :
2923 0 : static gboolean bd_fs_ntfs_set_label_stub (const gchar *device G_GNUC_UNUSED, const gchar *label G_GNUC_UNUSED, GError **error) {
2924 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ntfs_set_label' called, but not implemented!");
2925 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2926 : "The function 'bd_fs_ntfs_set_label' called, but not implemented!");
2927 0 : return FALSE;
2928 : }
2929 :
2930 : static gboolean (*_bd_fs_ntfs_set_label) (const gchar *device, const gchar *label, GError **error) = bd_fs_ntfs_set_label_stub;
2931 :
2932 : /**
2933 : * bd_fs_ntfs_set_label:
2934 : * @device: the device containing the file system to set the label for
2935 : * @label: label to set
2936 : * @error: (out) (optional): place to store error (if any)
2937 : *
2938 : * Returns: whether the label of the NTFS file system on the @device was
2939 : * successfully set or not
2940 : *
2941 : * Tech category: %BD_FS_TECH_NTFS-%BD_FS_TECH_MODE_SET_LABEL
2942 : */
2943 5 : gboolean bd_fs_ntfs_set_label (const gchar *device, const gchar *label, GError **error) {
2944 5 : return _bd_fs_ntfs_set_label (device, label, error);
2945 : }
2946 :
2947 :
2948 0 : static gboolean bd_fs_ntfs_check_label_stub (const gchar *label G_GNUC_UNUSED, GError **error) {
2949 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ntfs_check_label' called, but not implemented!");
2950 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2951 : "The function 'bd_fs_ntfs_check_label' called, but not implemented!");
2952 0 : return FALSE;
2953 : }
2954 :
2955 : static gboolean (*_bd_fs_ntfs_check_label) (const gchar *label, GError **error) = bd_fs_ntfs_check_label_stub;
2956 :
2957 : /**
2958 : * bd_fs_ntfs_check_label:
2959 : * @label: label to check
2960 : * @error: (out) (optional): place to store error
2961 : *
2962 : * Returns: whether @label is a valid label for the ntfs file system or not
2963 : * (reason is provided in @error)
2964 : *
2965 : * Tech category: always available
2966 : */
2967 4 : gboolean bd_fs_ntfs_check_label (const gchar *label, GError **error) {
2968 4 : return _bd_fs_ntfs_check_label (label, error);
2969 : }
2970 :
2971 :
2972 0 : static gboolean bd_fs_ntfs_set_uuid_stub (const gchar *device G_GNUC_UNUSED, const gchar *uuid G_GNUC_UNUSED, GError **error) {
2973 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ntfs_set_uuid' called, but not implemented!");
2974 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
2975 : "The function 'bd_fs_ntfs_set_uuid' called, but not implemented!");
2976 0 : return FALSE;
2977 : }
2978 :
2979 : static gboolean (*_bd_fs_ntfs_set_uuid) (const gchar *device, const gchar *uuid, GError **error) = bd_fs_ntfs_set_uuid_stub;
2980 :
2981 : /**
2982 : * bd_fs_ntfs_set_uuid:
2983 : * @device: the device containing the file system to set the UUID (serial number) for
2984 : * @uuid: (nullable): UUID to set or %NULL to generate a new one
2985 : * @error: (out) (optional): place to store error (if any)
2986 : *
2987 : * Returns: whether the UUID of the NTFS file system on the @device was
2988 : * successfully set or not
2989 : *
2990 : * Tech category: %BD_FS_TECH_NTFS-%BD_FS_TECH_MODE_SET_UUID
2991 : */
2992 4 : gboolean bd_fs_ntfs_set_uuid (const gchar *device, const gchar *uuid, GError **error) {
2993 4 : return _bd_fs_ntfs_set_uuid (device, uuid, error);
2994 : }
2995 :
2996 :
2997 0 : static gboolean bd_fs_ntfs_check_uuid_stub (const gchar *uuid G_GNUC_UNUSED, GError **error) {
2998 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ntfs_check_uuid' called, but not implemented!");
2999 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3000 : "The function 'bd_fs_ntfs_check_uuid' called, but not implemented!");
3001 0 : return FALSE;
3002 : }
3003 :
3004 : static gboolean (*_bd_fs_ntfs_check_uuid) (const gchar *uuid, GError **error) = bd_fs_ntfs_check_uuid_stub;
3005 :
3006 : /**
3007 : * bd_fs_ntfs_check_uuid:
3008 : * @uuid: UUID to check
3009 : * @error: (out) (optional): place to store error
3010 : *
3011 : * Returns: whether @uuid is a valid UUID for the ntfs file system or not
3012 : * (reason is provided in @error)
3013 : *
3014 : * Tech category: always available
3015 : */
3016 4 : gboolean bd_fs_ntfs_check_uuid (const gchar *uuid, GError **error) {
3017 4 : return _bd_fs_ntfs_check_uuid (uuid, error);
3018 : }
3019 :
3020 :
3021 0 : static gboolean bd_fs_ntfs_resize_stub (const gchar *device G_GNUC_UNUSED, guint64 new_size G_GNUC_UNUSED, GError **error) {
3022 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ntfs_resize' called, but not implemented!");
3023 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3024 : "The function 'bd_fs_ntfs_resize' called, but not implemented!");
3025 0 : return FALSE;
3026 : }
3027 :
3028 : static gboolean (*_bd_fs_ntfs_resize) (const gchar *device, guint64 new_size, GError **error) = bd_fs_ntfs_resize_stub;
3029 :
3030 : /**
3031 : * bd_fs_ntfs_resize:
3032 : * @device: the device the file system of which to resize
3033 : * @new_size: new requested size for the file system in bytes (if 0, the file system
3034 : * is adapted to the underlying block device)
3035 : * @error: (out) (optional): place to store error (if any)
3036 : *
3037 : * Returns: whether the file system on @device was successfully resized or not
3038 : *
3039 : * Tech category: %BD_FS_TECH_NTFS-%BD_FS_TECH_MODE_RESIZE
3040 : */
3041 5 : gboolean bd_fs_ntfs_resize (const gchar *device, guint64 new_size, GError **error) {
3042 5 : return _bd_fs_ntfs_resize (device, new_size, error);
3043 : }
3044 :
3045 :
3046 0 : static BDFSNtfsInfo* bd_fs_ntfs_get_info_stub (const gchar *device G_GNUC_UNUSED, GError **error) {
3047 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ntfs_get_info' called, but not implemented!");
3048 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3049 : "The function 'bd_fs_ntfs_get_info' called, but not implemented!");
3050 0 : return NULL;
3051 : }
3052 :
3053 : static BDFSNtfsInfo* (*_bd_fs_ntfs_get_info) (const gchar *device, GError **error) = bd_fs_ntfs_get_info_stub;
3054 :
3055 : /**
3056 : * bd_fs_ntfs_get_info:
3057 : * @device: the device containing the file system to get info for (device must
3058 : not be mounted, trying to get info for a mounted device will result
3059 : in an error)
3060 : * @error: (out) (optional): place to store error (if any)
3061 : *
3062 : * Returns: (transfer full): information about the file system on @device or
3063 : * %NULL in case of error
3064 : *
3065 : * Tech category: %BD_FS_TECH_NTFS-%BD_FS_TECH_MODE_QUERY
3066 : */
3067 17 : BDFSNtfsInfo* bd_fs_ntfs_get_info (const gchar *device, GError **error) {
3068 17 : return _bd_fs_ntfs_get_info (device, error);
3069 : }
3070 :
3071 :
3072 0 : static guint64 bd_fs_ntfs_get_min_size_stub (const gchar *device G_GNUC_UNUSED, GError **error) {
3073 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_ntfs_get_min_size' called, but not implemented!");
3074 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3075 : "The function 'bd_fs_ntfs_get_min_size' called, but not implemented!");
3076 0 : return 0;
3077 : }
3078 :
3079 : static guint64 (*_bd_fs_ntfs_get_min_size) (const gchar *device, GError **error) = bd_fs_ntfs_get_min_size_stub;
3080 :
3081 : /**
3082 : * bd_fs_ntfs_get_min_size:
3083 : * @device: the device containing the file system to get min size for
3084 : * @error: (out) (optional): place to store error (if any)
3085 : *
3086 : * Returns: smallest shrunken filesystem size as reported by ntfsresize
3087 : * in case of error 0 is returned and @error is set
3088 : *
3089 : * Tech category: %BD_FS_TECH_NTFS-%BD_FS_TECH_MODE_RESIZE
3090 : */
3091 2 : guint64 bd_fs_ntfs_get_min_size (const gchar *device, GError **error) {
3092 2 : return _bd_fs_ntfs_get_min_size (device, error);
3093 : }
3094 :
3095 :
3096 0 : static gboolean bd_fs_f2fs_mkfs_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
3097 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_f2fs_mkfs' called, but not implemented!");
3098 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3099 : "The function 'bd_fs_f2fs_mkfs' called, but not implemented!");
3100 0 : return FALSE;
3101 : }
3102 :
3103 : static gboolean (*_bd_fs_f2fs_mkfs) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_f2fs_mkfs_stub;
3104 :
3105 : /**
3106 : * bd_fs_f2fs_mkfs:
3107 : * @device: the device to create a new f2fs fs on
3108 : * @extra: (nullable) (array zero-terminated=1): extra options for the creation (right now
3109 : * passed to the 'mkfs.f2fs' utility)
3110 : * @error: (out) (optional): place to store error (if any)
3111 : *
3112 : * Returns: whether a new f2fs fs was successfully created on @device or not
3113 : *
3114 : * Tech category: %BD_FS_TECH_F2FS-%BD_FS_TECH_MODE_MKFS
3115 : */
3116 18 : gboolean bd_fs_f2fs_mkfs (const gchar *device, const BDExtraArg **extra, GError **error) {
3117 18 : return _bd_fs_f2fs_mkfs (device, extra, error);
3118 : }
3119 :
3120 :
3121 0 : static gboolean bd_fs_f2fs_check_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
3122 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_f2fs_check' called, but not implemented!");
3123 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3124 : "The function 'bd_fs_f2fs_check' called, but not implemented!");
3125 0 : return FALSE;
3126 : }
3127 :
3128 : static gboolean (*_bd_fs_f2fs_check) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_f2fs_check_stub;
3129 :
3130 : /**
3131 : * bd_fs_f2fs_check:
3132 : * @device: the device containing the file system to check
3133 : * @extra: (nullable) (array zero-terminated=1): extra options for the repair (right now
3134 : * passed to the 'fsck.f2fs' utility)
3135 : * @error: (out) (optional): place to store error (if any)
3136 : *
3137 : * Returns: whether an f2fs file system on the @device is clean or not
3138 : *
3139 : * Tech category: %BD_FS_TECH_F2FS-%BD_FS_TECH_MODE_CHECK
3140 : */
3141 3 : gboolean bd_fs_f2fs_check (const gchar *device, const BDExtraArg **extra, GError **error) {
3142 3 : return _bd_fs_f2fs_check (device, extra, error);
3143 : }
3144 :
3145 :
3146 0 : static gboolean bd_fs_f2fs_repair_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
3147 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_f2fs_repair' called, but not implemented!");
3148 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3149 : "The function 'bd_fs_f2fs_repair' called, but not implemented!");
3150 0 : return FALSE;
3151 : }
3152 :
3153 : static gboolean (*_bd_fs_f2fs_repair) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_f2fs_repair_stub;
3154 :
3155 : /**
3156 : * bd_fs_f2fs_repair:
3157 : * @device: the device containing the file system to repair
3158 : * @extra: (nullable) (array zero-terminated=1): extra options for the repair (right now
3159 : * passed to the 'fsck.f2fs' utility)
3160 : * @error: (out) (optional): place to store error (if any)
3161 : *
3162 : * Returns: whether an f2fs file system on the @device was successfully repaired
3163 : * (if needed) or not (error is set in that case)
3164 : *
3165 : * Tech category: %BD_FS_TECH_F2FS-%BD_FS_TECH_MODE_REPAIR
3166 : */
3167 3 : gboolean bd_fs_f2fs_repair (const gchar *device, const BDExtraArg **extra, GError **error) {
3168 3 : return _bd_fs_f2fs_repair (device, extra, error);
3169 : }
3170 :
3171 :
3172 0 : static BDFSF2FSInfo* bd_fs_f2fs_get_info_stub (const gchar *device G_GNUC_UNUSED, GError **error) {
3173 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_f2fs_get_info' called, but not implemented!");
3174 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3175 : "The function 'bd_fs_f2fs_get_info' called, but not implemented!");
3176 0 : return NULL;
3177 : }
3178 :
3179 : static BDFSF2FSInfo* (*_bd_fs_f2fs_get_info) (const gchar *device, GError **error) = bd_fs_f2fs_get_info_stub;
3180 :
3181 : /**
3182 : * bd_fs_f2fs_get_info:
3183 : * @device: the device containing the file system to get info for
3184 : * @error: (out) (optional): place to store error (if any)
3185 : *
3186 : * Returns: (transfer full): information about the file system on @device or
3187 : * %NULL in case of error
3188 : *
3189 : * Tech category: %BD_FS_TECH_F2FS-%BD_FS_TECH_MODE_QUERY
3190 : */
3191 8 : BDFSF2FSInfo* bd_fs_f2fs_get_info (const gchar *device, GError **error) {
3192 8 : return _bd_fs_f2fs_get_info (device, error);
3193 : }
3194 :
3195 :
3196 0 : static gboolean bd_fs_f2fs_resize_stub (const gchar *device G_GNUC_UNUSED, guint64 new_size G_GNUC_UNUSED, gboolean safe G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
3197 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_f2fs_resize' called, but not implemented!");
3198 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3199 : "The function 'bd_fs_f2fs_resize' called, but not implemented!");
3200 0 : return FALSE;
3201 : }
3202 :
3203 : static gboolean (*_bd_fs_f2fs_resize) (const gchar *device, guint64 new_size, gboolean safe, const BDExtraArg **extra, GError **error) = bd_fs_f2fs_resize_stub;
3204 :
3205 : /**
3206 : * bd_fs_f2fs_resize:
3207 : * @device: the device containing the file system to resize
3208 : * @new_size: new requested size for the file system *in file system sectors* (see bd_fs_f2fs_get_info())
3209 : * (if 0, the file system is adapted to the underlying block device)
3210 : * @safe: whether to perform safe resize or not (does not resize metadata)
3211 : * @extra: (nullable) (array zero-terminated=1): extra options for the resize (right now
3212 : * passed to the 'resize.f2fs' utility)
3213 : * @error: (out) (optional): place to store error (if any)
3214 : *
3215 : * Returns: whether the file system on @device was successfully resized or not
3216 : *
3217 : * Tech category: %BD_FS_TECH_F2FS-%BD_FS_TECH_MODE_RESIZE
3218 : */
3219 2 : gboolean bd_fs_f2fs_resize (const gchar *device, guint64 new_size, gboolean safe, const BDExtraArg **extra, GError **error) {
3220 2 : return _bd_fs_f2fs_resize (device, new_size, safe, extra, error);
3221 : }
3222 :
3223 :
3224 0 : static gboolean bd_fs_f2fs_check_label_stub (const gchar *label G_GNUC_UNUSED, GError **error) {
3225 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_f2fs_check_label' called, but not implemented!");
3226 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3227 : "The function 'bd_fs_f2fs_check_label' called, but not implemented!");
3228 0 : return FALSE;
3229 : }
3230 :
3231 : static gboolean (*_bd_fs_f2fs_check_label) (const gchar *label, GError **error) = bd_fs_f2fs_check_label_stub;
3232 :
3233 : /**
3234 : * bd_fs_f2fs_check_label:
3235 : * @label: label to check
3236 : * @error: (out) (optional): place to store error
3237 : *
3238 : * Returns: whether @label is a valid label for the f2fs file system or not
3239 : * (reason is provided in @error)
3240 : *
3241 : * Tech category: always available
3242 : */
3243 4 : gboolean bd_fs_f2fs_check_label (const gchar *label, GError **error) {
3244 4 : return _bd_fs_f2fs_check_label (label, error);
3245 : }
3246 :
3247 :
3248 0 : static gboolean bd_fs_nilfs2_mkfs_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
3249 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_nilfs2_mkfs' called, but not implemented!");
3250 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3251 : "The function 'bd_fs_nilfs2_mkfs' called, but not implemented!");
3252 0 : return FALSE;
3253 : }
3254 :
3255 : static gboolean (*_bd_fs_nilfs2_mkfs) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_nilfs2_mkfs_stub;
3256 :
3257 : /**
3258 : * bd_fs_nilfs2_mkfs:
3259 : * @device: the device to create a new nilfs fs on
3260 : * @extra: (nullable) (array zero-terminated=1): extra options for the creation (right now
3261 : * passed to the 'mkfs.nilfs2' utility)
3262 : * @error: (out) (optional): place to store error (if any)
3263 : *
3264 : * Returns: whether a new nilfs fs was successfully created on @device or not
3265 : *
3266 : * Tech category: %BD_FS_TECH_NILFS2-%BD_FS_TECH_MODE_MKFS
3267 : */
3268 22 : gboolean bd_fs_nilfs2_mkfs (const gchar *device, const BDExtraArg **extra, GError **error) {
3269 22 : return _bd_fs_nilfs2_mkfs (device, extra, error);
3270 : }
3271 :
3272 :
3273 0 : static gboolean bd_fs_nilfs2_set_label_stub (const gchar *device G_GNUC_UNUSED, const gchar *label G_GNUC_UNUSED, GError **error) {
3274 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_nilfs2_set_label' called, but not implemented!");
3275 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3276 : "The function 'bd_fs_nilfs2_set_label' called, but not implemented!");
3277 0 : return FALSE;
3278 : }
3279 :
3280 : static gboolean (*_bd_fs_nilfs2_set_label) (const gchar *device, const gchar *label, GError **error) = bd_fs_nilfs2_set_label_stub;
3281 :
3282 : /**
3283 : * bd_fs_nilfs2_set_label:
3284 : * @device: the device containing the file system to set label for
3285 : * @label: label to set
3286 : * @error: (out) (optional): place to store error (if any)
3287 : *
3288 : * Returns: whether the label of nilfs file system on the @device was
3289 : * successfully set or not
3290 : *
3291 : * Tech category: %BD_FS_TECH_NILFS2-%BD_FS_TECH_MODE_SET_LABEL
3292 : */
3293 5 : gboolean bd_fs_nilfs2_set_label (const gchar *device, const gchar *label, GError **error) {
3294 5 : return _bd_fs_nilfs2_set_label (device, label, error);
3295 : }
3296 :
3297 :
3298 0 : static gboolean bd_fs_nilfs2_check_label_stub (const gchar *label G_GNUC_UNUSED, GError **error) {
3299 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_nilfs2_check_label' called, but not implemented!");
3300 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3301 : "The function 'bd_fs_nilfs2_check_label' called, but not implemented!");
3302 0 : return FALSE;
3303 : }
3304 :
3305 : static gboolean (*_bd_fs_nilfs2_check_label) (const gchar *label, GError **error) = bd_fs_nilfs2_check_label_stub;
3306 :
3307 : /**
3308 : * bd_fs_nilfs2_check_label:
3309 : * @label: label to check
3310 : * @error: (out) (optional): place to store error
3311 : *
3312 : * Returns: whether @label is a valid label for the nilfs2 file system or not
3313 : * (reason is provided in @error)
3314 : *
3315 : * Tech category: always available
3316 : */
3317 4 : gboolean bd_fs_nilfs2_check_label (const gchar *label, GError **error) {
3318 4 : return _bd_fs_nilfs2_check_label (label, error);
3319 : }
3320 :
3321 :
3322 0 : static gboolean bd_fs_nilfs2_set_uuid_stub (const gchar *device G_GNUC_UNUSED, const gchar *uuid G_GNUC_UNUSED, GError **error) {
3323 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_nilfs2_set_uuid' called, but not implemented!");
3324 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3325 : "The function 'bd_fs_nilfs2_set_uuid' called, but not implemented!");
3326 0 : return FALSE;
3327 : }
3328 :
3329 : static gboolean (*_bd_fs_nilfs2_set_uuid) (const gchar *device, const gchar *uuid, GError **error) = bd_fs_nilfs2_set_uuid_stub;
3330 :
3331 : /**
3332 : * bd_fs_nilfs2_set_uuid:
3333 : * @device: the device containing the file system to set UUID for
3334 : * @uuid: (nullable): UUID to set or %NULL to generate a new one
3335 : * @error: (out) (optional): place to store error (if any)
3336 : *
3337 : * Returns: whether the uuid of nilfs file system on the @device was
3338 : * successfully set or not
3339 : *
3340 : * Tech category: %BD_FS_TECH_NILFS2-%BD_FS_TECH_MODE_SET_UUID
3341 : */
3342 4 : gboolean bd_fs_nilfs2_set_uuid (const gchar *device, const gchar *uuid, GError **error) {
3343 4 : return _bd_fs_nilfs2_set_uuid (device, uuid, error);
3344 : }
3345 :
3346 :
3347 0 : static gboolean bd_fs_nilfs2_check_uuid_stub (const gchar *uuid G_GNUC_UNUSED, GError **error) {
3348 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_nilfs2_check_uuid' called, but not implemented!");
3349 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3350 : "The function 'bd_fs_nilfs2_check_uuid' called, but not implemented!");
3351 0 : return FALSE;
3352 : }
3353 :
3354 : static gboolean (*_bd_fs_nilfs2_check_uuid) (const gchar *uuid, GError **error) = bd_fs_nilfs2_check_uuid_stub;
3355 :
3356 : /**
3357 : * bd_fs_nilfs2_check_uuid:
3358 : * @uuid: UUID to check
3359 : * @error: (out) (optional): place to store error
3360 : *
3361 : * Returns: whether @uuid is a valid UUID for the nilfs file system or not
3362 : * (reason is provided in @error)
3363 : *
3364 : * Tech category: always available
3365 : */
3366 3 : gboolean bd_fs_nilfs2_check_uuid (const gchar *uuid, GError **error) {
3367 3 : return _bd_fs_nilfs2_check_uuid (uuid, error);
3368 : }
3369 :
3370 :
3371 0 : static BDFSNILFS2Info* bd_fs_nilfs2_get_info_stub (const gchar *device G_GNUC_UNUSED, GError **error) {
3372 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_nilfs2_get_info' called, but not implemented!");
3373 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3374 : "The function 'bd_fs_nilfs2_get_info' called, but not implemented!");
3375 0 : return NULL;
3376 : }
3377 :
3378 : static BDFSNILFS2Info* (*_bd_fs_nilfs2_get_info) (const gchar *device, GError **error) = bd_fs_nilfs2_get_info_stub;
3379 :
3380 : /**
3381 : * bd_fs_nilfs2_get_info:
3382 : * @device: the device containing the file system to get info for
3383 : * @error: (out) (optional): place to store error (if any)
3384 : *
3385 : * Returns: (transfer full): information about the file system on @device or
3386 : * %NULL in case of error
3387 : *
3388 : * Tech category: %BD_FS_TECH_NILFS2-%BD_FS_TECH_MODE_QUERY
3389 : */
3390 17 : BDFSNILFS2Info* bd_fs_nilfs2_get_info (const gchar *device, GError **error) {
3391 17 : return _bd_fs_nilfs2_get_info (device, error);
3392 : }
3393 :
3394 :
3395 0 : static gboolean bd_fs_nilfs2_resize_stub (const gchar *device G_GNUC_UNUSED, guint64 new_size G_GNUC_UNUSED, GError **error) {
3396 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_nilfs2_resize' called, but not implemented!");
3397 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3398 : "The function 'bd_fs_nilfs2_resize' called, but not implemented!");
3399 0 : return FALSE;
3400 : }
3401 :
3402 : static gboolean (*_bd_fs_nilfs2_resize) (const gchar *device, guint64 new_size, GError **error) = bd_fs_nilfs2_resize_stub;
3403 :
3404 : /**
3405 : * bd_fs_nilfs2_resize:
3406 : * @device: the device the file system of which to resize
3407 : * @new_size: new requested size for the file system (if 0, the file system is
3408 : * adapted to the underlying block device)
3409 : * @error: (out) (optional): place to store error (if any)
3410 : *
3411 : * Returns: whether the file system on @device was successfully resized or not
3412 : *
3413 : * Tech category: %BD_FS_TECH_NILFS2-%BD_FS_TECH_MODE_RESIZE
3414 : */
3415 7 : gboolean bd_fs_nilfs2_resize (const gchar *device, guint64 new_size, GError **error) {
3416 7 : return _bd_fs_nilfs2_resize (device, new_size, error);
3417 : }
3418 :
3419 :
3420 0 : static gboolean bd_fs_exfat_mkfs_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
3421 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_exfat_mkfs' called, but not implemented!");
3422 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3423 : "The function 'bd_fs_exfat_mkfs' called, but not implemented!");
3424 0 : return FALSE;
3425 : }
3426 :
3427 : static gboolean (*_bd_fs_exfat_mkfs) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_exfat_mkfs_stub;
3428 :
3429 : /**
3430 : * bd_fs_exfat_mkfs:
3431 : * @device: the device to create a new exfat fs on
3432 : * @extra: (nullable) (array zero-terminated=1): extra options for the creation (right now
3433 : * passed to the 'mkexfatfs' utility)
3434 : * @error: (out) (optional): place to store error (if any)
3435 : *
3436 : * Returns: whether a new exfat fs was successfully created on @device or not
3437 : *
3438 : * Tech category: %BD_FS_TECH_EXFAT-%BD_FS_TECH_MODE_MKFS
3439 : */
3440 14 : gboolean bd_fs_exfat_mkfs (const gchar *device, const BDExtraArg **extra, GError **error) {
3441 14 : return _bd_fs_exfat_mkfs (device, extra, error);
3442 : }
3443 :
3444 :
3445 0 : static gboolean bd_fs_exfat_check_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
3446 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_exfat_check' called, but not implemented!");
3447 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3448 : "The function 'bd_fs_exfat_check' called, but not implemented!");
3449 0 : return FALSE;
3450 : }
3451 :
3452 : static gboolean (*_bd_fs_exfat_check) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_exfat_check_stub;
3453 :
3454 : /**
3455 : * bd_fs_exfat_check:
3456 : * @device: the device containing the file system to check
3457 : * @extra: (nullable) (array zero-terminated=1): extra options for the repair (right now
3458 : * passed to the 'exfatfsck' utility)
3459 : * @error: (out) (optional): place to store error (if any)
3460 : *
3461 : * Returns: whether the exfat file system on the @device is clean or not
3462 : *
3463 : * Tech category: %BD_FS_TECH_EXFAT-%BD_FS_TECH_MODE_CHECK
3464 : */
3465 3 : gboolean bd_fs_exfat_check (const gchar *device, const BDExtraArg **extra, GError **error) {
3466 3 : return _bd_fs_exfat_check (device, extra, error);
3467 : }
3468 :
3469 :
3470 0 : static gboolean bd_fs_exfat_repair_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
3471 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_exfat_repair' called, but not implemented!");
3472 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3473 : "The function 'bd_fs_exfat_repair' called, but not implemented!");
3474 0 : return FALSE;
3475 : }
3476 :
3477 : static gboolean (*_bd_fs_exfat_repair) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_exfat_repair_stub;
3478 :
3479 : /**
3480 : * bd_fs_exfat_repair:
3481 : * @device: the device containing the file system to repair
3482 : * @extra: (nullable) (array zero-terminated=1): extra options for the repair (right now
3483 : * passed to the 'exfatfsck' utility)
3484 : * @error: (out) (optional): place to store error (if any)
3485 : *
3486 : * Returns: whether the exfat file system on the @device was successfully repaired
3487 : * (if needed) or not (error is set in that case)
3488 : *
3489 : * Tech category: %BD_FS_TECH_EXFAT-%BD_FS_TECH_MODE_REPAIR
3490 : */
3491 3 : gboolean bd_fs_exfat_repair (const gchar *device, const BDExtraArg **extra, GError **error) {
3492 3 : return _bd_fs_exfat_repair (device, extra, error);
3493 : }
3494 :
3495 :
3496 0 : static gboolean bd_fs_exfat_set_label_stub (const gchar *device G_GNUC_UNUSED, const gchar *label G_GNUC_UNUSED, GError **error) {
3497 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_exfat_set_label' called, but not implemented!");
3498 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3499 : "The function 'bd_fs_exfat_set_label' called, but not implemented!");
3500 0 : return FALSE;
3501 : }
3502 :
3503 : static gboolean (*_bd_fs_exfat_set_label) (const gchar *device, const gchar *label, GError **error) = bd_fs_exfat_set_label_stub;
3504 :
3505 : /**
3506 : * bd_fs_exfat_set_label:
3507 : * @device: the device containing the file system to set label for
3508 : * @label: label to set
3509 : * @error: (out) (optional): place to store error (if any)
3510 : *
3511 : * Returns: whether the label of exfat file system on the @device was
3512 : * successfully set or not
3513 : *
3514 : * Tech category: %BD_FS_TECH_EXFAT-%BD_FS_TECH_MODE_SET_LABEL
3515 : */
3516 5 : gboolean bd_fs_exfat_set_label (const gchar *device, const gchar *label, GError **error) {
3517 5 : return _bd_fs_exfat_set_label (device, label, error);
3518 : }
3519 :
3520 :
3521 0 : static gboolean bd_fs_exfat_check_label_stub (const gchar *label G_GNUC_UNUSED, GError **error) {
3522 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_exfat_check_label' called, but not implemented!");
3523 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3524 : "The function 'bd_fs_exfat_check_label' called, but not implemented!");
3525 0 : return FALSE;
3526 : }
3527 :
3528 : static gboolean (*_bd_fs_exfat_check_label) (const gchar *label, GError **error) = bd_fs_exfat_check_label_stub;
3529 :
3530 : /**
3531 : * bd_fs_exfat_check_label:
3532 : * @label: label to check
3533 : * @error: (out) (optional): place to store error
3534 : *
3535 : * Returns: whether @label is a valid label for the exfat file system or not
3536 : * (reason is provided in @error)
3537 : *
3538 : * Tech category: always available
3539 : */
3540 4 : gboolean bd_fs_exfat_check_label (const gchar *label, GError **error) {
3541 4 : return _bd_fs_exfat_check_label (label, error);
3542 : }
3543 :
3544 :
3545 0 : static gboolean bd_fs_exfat_set_uuid_stub (const gchar *device G_GNUC_UNUSED, const gchar *uuid G_GNUC_UNUSED, GError **error) {
3546 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_exfat_set_uuid' called, but not implemented!");
3547 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3548 : "The function 'bd_fs_exfat_set_uuid' called, but not implemented!");
3549 0 : return FALSE;
3550 : }
3551 :
3552 : static gboolean (*_bd_fs_exfat_set_uuid) (const gchar *device, const gchar *uuid, GError **error) = bd_fs_exfat_set_uuid_stub;
3553 :
3554 : /**
3555 : * bd_fs_exfat_set_uuid:
3556 : * @device: the device containing the file system to set uuid for
3557 : * @uuid: (nullable): volume ID to set or %NULL to generate a new one
3558 : * @error: (out) (optional): place to store error (if any)
3559 : *
3560 : * Returns: whether the volume ID of exFAT file system on the @device was
3561 : * successfully set or not
3562 : *
3563 : * Tech category: %BD_FS_TECH_EXFAT-%BD_FS_TECH_MODE_SET_UUID
3564 : */
3565 6 : gboolean bd_fs_exfat_set_uuid (const gchar *device, const gchar *uuid, GError **error) {
3566 6 : return _bd_fs_exfat_set_uuid (device, uuid, error);
3567 : }
3568 :
3569 :
3570 0 : static gboolean bd_fs_exfat_check_uuid_stub (const gchar *uuid G_GNUC_UNUSED, GError **error) {
3571 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_exfat_check_uuid' called, but not implemented!");
3572 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3573 : "The function 'bd_fs_exfat_check_uuid' called, but not implemented!");
3574 0 : return FALSE;
3575 : }
3576 :
3577 : static gboolean (*_bd_fs_exfat_check_uuid) (const gchar *uuid, GError **error) = bd_fs_exfat_check_uuid_stub;
3578 :
3579 : /**
3580 : * bd_fs_exfat_check_uuid:
3581 : * @uuid: UUID to check
3582 : * @error: (out) (optional): place to store error
3583 : *
3584 : * Returns: whether @uuid is a valid UUID for the exFAT file system or not
3585 : * (reason is provided in @error)
3586 : *
3587 : * Tech category: always available
3588 : */
3589 8 : gboolean bd_fs_exfat_check_uuid (const gchar *uuid, GError **error) {
3590 8 : return _bd_fs_exfat_check_uuid (uuid, error);
3591 : }
3592 :
3593 :
3594 0 : static BDFSExfatInfo* bd_fs_exfat_get_info_stub (const gchar *device G_GNUC_UNUSED, GError **error) {
3595 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_exfat_get_info' called, but not implemented!");
3596 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3597 : "The function 'bd_fs_exfat_get_info' called, but not implemented!");
3598 0 : return NULL;
3599 : }
3600 :
3601 : static BDFSExfatInfo* (*_bd_fs_exfat_get_info) (const gchar *device, GError **error) = bd_fs_exfat_get_info_stub;
3602 :
3603 : /**
3604 : * bd_fs_exfat_get_info:
3605 : * @device: the device containing the file system to get info for
3606 : * @error: (out) (optional): place to store error (if any)
3607 : *
3608 : * Returns: (transfer full): information about the file system on @device or
3609 : * %NULL in case of error
3610 : * Tech category: %BD_FS_TECH_EXFAT-%BD_FS_TECH_MODE_QUERY
3611 : */
3612 11 : BDFSExfatInfo* bd_fs_exfat_get_info (const gchar *device, GError **error) {
3613 11 : return _bd_fs_exfat_get_info (device, error);
3614 : }
3615 :
3616 :
3617 0 : static gboolean bd_fs_btrfs_mkfs_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
3618 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_btrfs_mkfs' called, but not implemented!");
3619 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3620 : "The function 'bd_fs_btrfs_mkfs' called, but not implemented!");
3621 0 : return FALSE;
3622 : }
3623 :
3624 : static gboolean (*_bd_fs_btrfs_mkfs) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_btrfs_mkfs_stub;
3625 :
3626 : /**
3627 : * bd_fs_btrfs_mkfs:
3628 : * @device: the device to create a new btrfs fs on
3629 : * @extra: (nullable) (array zero-terminated=1): extra options for the creation (right now
3630 : * passed to the 'mkfs.btrfs' utility)
3631 : * @error: (out) (optional): place to store error (if any)
3632 : *
3633 : * Returns: whether a new btrfs fs was successfully created on @device or not
3634 : *
3635 : * Tech category: %BD_FS_TECH_BTRFS-%BD_FS_TECH_MODE_MKFS
3636 : *
3637 : */
3638 22 : gboolean bd_fs_btrfs_mkfs (const gchar *device, const BDExtraArg **extra, GError **error) {
3639 22 : return _bd_fs_btrfs_mkfs (device, extra, error);
3640 : }
3641 :
3642 :
3643 0 : static gboolean bd_fs_btrfs_check_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
3644 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_btrfs_check' called, but not implemented!");
3645 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3646 : "The function 'bd_fs_btrfs_check' called, but not implemented!");
3647 0 : return FALSE;
3648 : }
3649 :
3650 : static gboolean (*_bd_fs_btrfs_check) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_btrfs_check_stub;
3651 :
3652 : /**
3653 : * bd_fs_btrfs_check:
3654 : * @device: the device containing the file system to check
3655 : * @extra: (nullable) (array zero-terminated=1): extra options for the check (right now
3656 : * passed to the 'btrfsck' utility)
3657 : * @error: (out) (optional): place to store error (if any)
3658 : *
3659 : * Returns: whether the filesystem was successfully checked or not
3660 : *
3661 : * Tech category: %BD_FS_TECH_BTRFS-%BD_FS_TECH_MODE_CHECK
3662 : */
3663 3 : gboolean bd_fs_btrfs_check (const gchar *device, const BDExtraArg **extra, GError **error) {
3664 3 : return _bd_fs_btrfs_check (device, extra, error);
3665 : }
3666 :
3667 :
3668 0 : static gboolean bd_fs_btrfs_repair_stub (const gchar *device G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
3669 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_btrfs_repair' called, but not implemented!");
3670 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3671 : "The function 'bd_fs_btrfs_repair' called, but not implemented!");
3672 0 : return FALSE;
3673 : }
3674 :
3675 : static gboolean (*_bd_fs_btrfs_repair) (const gchar *device, const BDExtraArg **extra, GError **error) = bd_fs_btrfs_repair_stub;
3676 :
3677 : /**
3678 : * bd_fs_btrfs_repair:
3679 : * @device: the device containing the file system to repair
3680 : * @extra: (nullable) (array zero-terminated=1): extra options for the repair (right now
3681 : * passed to the 'btrfs' utility)
3682 : * @error: (out) (optional): place to store error (if any)
3683 : *
3684 : * Returns: whether the filesystem was successfully checked and repaired or not
3685 : *
3686 : * Tech category: %BD_FS_TECH_BTRFS-%BD_FS_TECH_MODE_REPAIR
3687 : */
3688 3 : gboolean bd_fs_btrfs_repair (const gchar *device, const BDExtraArg **extra, GError **error) {
3689 3 : return _bd_fs_btrfs_repair (device, extra, error);
3690 : }
3691 :
3692 :
3693 0 : static gboolean bd_fs_btrfs_set_label_stub (const gchar *mpoint G_GNUC_UNUSED, const gchar *label G_GNUC_UNUSED, GError **error) {
3694 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_btrfs_set_label' called, but not implemented!");
3695 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3696 : "The function 'bd_fs_btrfs_set_label' called, but not implemented!");
3697 0 : return FALSE;
3698 : }
3699 :
3700 : static gboolean (*_bd_fs_btrfs_set_label) (const gchar *mpoint, const gchar *label, GError **error) = bd_fs_btrfs_set_label_stub;
3701 :
3702 : /**
3703 : * bd_fs_btrfs_set_label:
3704 : * @mpoint: the mount point of the file system to set label for
3705 : * @label: label to set
3706 : * @error: (out) (optional): place to store error (if any)
3707 : *
3708 : * Returns: whether the label of Btrfs file system on the @mpoint was
3709 : * successfully set or not
3710 : *
3711 : * Note: This function is intended to be used for btrfs filesystem on a single device,
3712 : * for more complicated setups use the btrfs plugin instead.
3713 : *
3714 : * Tech category: %BD_FS_TECH_BTRFS-%BD_FS_TECH_MODE_SET_LABEL
3715 : */
3716 5 : gboolean bd_fs_btrfs_set_label (const gchar *mpoint, const gchar *label, GError **error) {
3717 5 : return _bd_fs_btrfs_set_label (mpoint, label, error);
3718 : }
3719 :
3720 :
3721 0 : static gboolean bd_fs_btrfs_check_label_stub (const gchar *label G_GNUC_UNUSED, GError **error) {
3722 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_btrfs_check_label' called, but not implemented!");
3723 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3724 : "The function 'bd_fs_btrfs_check_label' called, but not implemented!");
3725 0 : return FALSE;
3726 : }
3727 :
3728 : static gboolean (*_bd_fs_btrfs_check_label) (const gchar *label, GError **error) = bd_fs_btrfs_check_label_stub;
3729 :
3730 : /**
3731 : * bd_fs_btrfs_check_label:
3732 : * @label: label to check
3733 : * @error: (out) (optional): place to store error
3734 : *
3735 : * Returns: whether @label is a valid label for the Btrfs file system or not
3736 : * (reason is provided in @error)
3737 : *
3738 : * Note: This function is intended to be used for btrfs filesystem on a single device,
3739 : * for more complicated setups use the btrfs plugin instead.
3740 : *
3741 : * Tech category: always available
3742 : */
3743 5 : gboolean bd_fs_btrfs_check_label (const gchar *label, GError **error) {
3744 5 : return _bd_fs_btrfs_check_label (label, error);
3745 : }
3746 :
3747 :
3748 0 : static gboolean bd_fs_btrfs_set_uuid_stub (const gchar *device G_GNUC_UNUSED, const gchar *uuid G_GNUC_UNUSED, GError **error) {
3749 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_btrfs_set_uuid' called, but not implemented!");
3750 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3751 : "The function 'bd_fs_btrfs_set_uuid' called, but not implemented!");
3752 0 : return FALSE;
3753 : }
3754 :
3755 : static gboolean (*_bd_fs_btrfs_set_uuid) (const gchar *device, const gchar *uuid, GError **error) = bd_fs_btrfs_set_uuid_stub;
3756 :
3757 : /**
3758 : * bd_fs_btrfs_set_uuid:
3759 : * @device: the device containing the file system to set the UUID (serial number) for
3760 : * @uuid: (nullable): UUID to set or %NULL to generate a new one
3761 : * @error: (out) (optional): place to store error (if any)
3762 : *
3763 : * Returns: whether the UUID of the Btrfs file system on the @device was
3764 : * successfully set or not
3765 : *
3766 : * Note: This function is intended to be used for btrfs filesystem on a single device,
3767 : * for more complicated setups use the btrfs plugin instead.
3768 : *
3769 : * Tech category: %BD_FS_TECH_BTRFS-%BD_FS_TECH_MODE_SET_UUID
3770 : */
3771 4 : gboolean bd_fs_btrfs_set_uuid (const gchar *device, const gchar *uuid, GError **error) {
3772 4 : return _bd_fs_btrfs_set_uuid (device, uuid, error);
3773 : }
3774 :
3775 :
3776 0 : static gboolean bd_fs_btrfs_check_uuid_stub (const gchar *uuid G_GNUC_UNUSED, GError **error) {
3777 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_btrfs_check_uuid' called, but not implemented!");
3778 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3779 : "The function 'bd_fs_btrfs_check_uuid' called, but not implemented!");
3780 0 : return FALSE;
3781 : }
3782 :
3783 : static gboolean (*_bd_fs_btrfs_check_uuid) (const gchar *uuid, GError **error) = bd_fs_btrfs_check_uuid_stub;
3784 :
3785 : /**
3786 : * bd_fs_btrfs_check_uuid:
3787 : * @uuid: UUID to check
3788 : * @error: (out) (optional): place to store error
3789 : *
3790 : * Returns: whether @uuid is a valid UUID for the Btrfs file system or not
3791 : * (reason is provided in @error)
3792 : *
3793 : * Note: This function is intended to be used for btrfs filesystem on a single device,
3794 : * for more complicated setups use the btrfs plugin instead.
3795 : *
3796 : * Tech category: always available
3797 : */
3798 3 : gboolean bd_fs_btrfs_check_uuid (const gchar *uuid, GError **error) {
3799 3 : return _bd_fs_btrfs_check_uuid (uuid, error);
3800 : }
3801 :
3802 :
3803 0 : static BDFSBtrfsInfo* bd_fs_btrfs_get_info_stub (const gchar *mpoint G_GNUC_UNUSED, GError **error) {
3804 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_btrfs_get_info' called, but not implemented!");
3805 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3806 : "The function 'bd_fs_btrfs_get_info' called, but not implemented!");
3807 0 : return NULL;
3808 : }
3809 :
3810 : static BDFSBtrfsInfo* (*_bd_fs_btrfs_get_info) (const gchar *mpoint, GError **error) = bd_fs_btrfs_get_info_stub;
3811 :
3812 : /**
3813 : * bd_fs_btrfs_get_info:
3814 : * @mpoint: a mountpoint of the btrfs filesystem to get information about
3815 : * @error: (out) (optional): place to store error (if any)
3816 : *
3817 : * Returns: (transfer full): information about the file system on @device or
3818 : * %NULL in case of error
3819 : *
3820 : * Note: This function WON'T WORK for multi device btrfs filesystems,
3821 : * for more complicated setups use the btrfs plugin instead.
3822 : *
3823 : * Tech category: %BD_FS_TECH_BTRFS-%BD_FS_TECH_MODE_QUERY
3824 : */
3825 34 : BDFSBtrfsInfo* bd_fs_btrfs_get_info (const gchar *mpoint, GError **error) {
3826 34 : return _bd_fs_btrfs_get_info (mpoint, error);
3827 : }
3828 :
3829 :
3830 0 : static gboolean bd_fs_btrfs_resize_stub (const gchar *mpoint G_GNUC_UNUSED, guint64 new_size G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
3831 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_btrfs_resize' called, but not implemented!");
3832 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3833 : "The function 'bd_fs_btrfs_resize' called, but not implemented!");
3834 0 : return FALSE;
3835 : }
3836 :
3837 : static gboolean (*_bd_fs_btrfs_resize) (const gchar *mpoint, guint64 new_size, const BDExtraArg **extra, GError **error) = bd_fs_btrfs_resize_stub;
3838 :
3839 : /**
3840 : * bd_fs_btrfs_resize:
3841 : * @mpoint: a mountpoint of the to be resized btrfs filesystem
3842 : * @new_size: requested new size
3843 : * @extra: (nullable) (array zero-terminated=1): extra options for the volume resize (right now
3844 : * passed to the 'btrfs' utility)
3845 : * @error: (out) (optional): place to store error (if any)
3846 : *
3847 : * Returns: whether the @mpoint filesystem was successfully resized to @new_size
3848 : * or not
3849 : *
3850 : * Note: This function WON'T WORK for multi device btrfs filesystems,
3851 : * for more complicated setups use the btrfs plugin instead.
3852 : *
3853 : * Tech category: %BD_BTRFS_TECH_FS-%BD_BTRFS_TECH_MODE_MODIFY
3854 : */
3855 9 : gboolean bd_fs_btrfs_resize (const gchar *mpoint, guint64 new_size, const BDExtraArg **extra, GError **error) {
3856 9 : return _bd_fs_btrfs_resize (mpoint, new_size, extra, error);
3857 : }
3858 :
3859 :
3860 0 : static gboolean bd_fs_udf_mkfs_stub (const gchar *device G_GNUC_UNUSED, const gchar *media_type G_GNUC_UNUSED, gchar *revision G_GNUC_UNUSED, guint64 block_size G_GNUC_UNUSED, const BDExtraArg **extra G_GNUC_UNUSED, GError **error) {
3861 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_udf_mkfs' called, but not implemented!");
3862 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3863 : "The function 'bd_fs_udf_mkfs' called, but not implemented!");
3864 0 : return FALSE;
3865 : }
3866 :
3867 : static gboolean (*_bd_fs_udf_mkfs) (const gchar *device, const gchar *media_type, gchar *revision, guint64 block_size, const BDExtraArg **extra, GError **error) = bd_fs_udf_mkfs_stub;
3868 :
3869 : /**
3870 : * bd_fs_udf_mkfs:
3871 : * @device: the device to create a new UDF fs on
3872 : * @media_type: (nullable): specify the media type or %NULL for default ('hd')
3873 : * @revision: (nullable): UDF revision to use or %NULL for default ('2.01')
3874 : * @block_size: block size in bytes or 0 for auto detection (device logical block size)
3875 : * @extra: (nullable) (array zero-terminated=1): extra options for the creation (right now
3876 : * passed to the 'mkudffs' utility)
3877 : * @error: (out) (optional): place to store error (if any)
3878 : *
3879 : * Returns: whether a new UDF fs was successfully created on @device or not
3880 : *
3881 : * Tech category: %BD_FS_TECH_UDF-%BD_FS_TECH_MODE_MKFS
3882 : */
3883 12 : gboolean bd_fs_udf_mkfs (const gchar *device, const gchar *media_type, gchar *revision, guint64 block_size, const BDExtraArg **extra, GError **error) {
3884 12 : return _bd_fs_udf_mkfs (device, media_type, revision, block_size, extra, error);
3885 : }
3886 :
3887 :
3888 0 : static gboolean bd_fs_udf_set_label_stub (const gchar *device G_GNUC_UNUSED, const gchar *label G_GNUC_UNUSED, GError **error) {
3889 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_udf_set_label' called, but not implemented!");
3890 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3891 : "The function 'bd_fs_udf_set_label' called, but not implemented!");
3892 0 : return FALSE;
3893 : }
3894 :
3895 : static gboolean (*_bd_fs_udf_set_label) (const gchar *device, const gchar *label, GError **error) = bd_fs_udf_set_label_stub;
3896 :
3897 : /**
3898 : * bd_fs_udf_set_label:
3899 : * @device: the device containing the file system to set label for
3900 : * @label: label to set
3901 : * @error: (out) (optional): place to store error (if any)
3902 : *
3903 : * Note: This sets both Volume Identifier and Logical Volume Identifier. Volume Identifier
3904 : * is truncated to 30 or 15 characters to accommodate to the different length limits
3905 : * of these labels.
3906 : *
3907 : * Returns: whether the label of UDF file system on the @device was
3908 : * successfully set or not
3909 : *
3910 : * Tech category: %BD_FS_TECH_UDF-%BD_FS_TECH_MODE_SET_LABEL
3911 : */
3912 8 : gboolean bd_fs_udf_set_label (const gchar *device, const gchar *label, GError **error) {
3913 8 : return _bd_fs_udf_set_label (device, label, error);
3914 : }
3915 :
3916 :
3917 0 : static gboolean bd_fs_udf_check_label_stub (const gchar *label G_GNUC_UNUSED, GError **error) {
3918 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_udf_check_label' called, but not implemented!");
3919 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3920 : "The function 'bd_fs_udf_check_label' called, but not implemented!");
3921 0 : return FALSE;
3922 : }
3923 :
3924 : static gboolean (*_bd_fs_udf_check_label) (const gchar *label, GError **error) = bd_fs_udf_check_label_stub;
3925 :
3926 : /**
3927 : * bd_fs_udf_check_label:
3928 : * @label: label to check
3929 : * @error: (out) (optional): place to store error
3930 : *
3931 : * Note: This checks only whether @label adheres the length limits for Logical Volume Identifier,
3932 : * not the stricter limits for Volume Identifier.
3933 : *
3934 : * Returns: whether @label is a valid label for the UDF file system or not
3935 : * (reason is provided in @error)
3936 : *
3937 : * Tech category: always available
3938 : */
3939 15 : gboolean bd_fs_udf_check_label (const gchar *label, GError **error) {
3940 15 : return _bd_fs_udf_check_label (label, error);
3941 : }
3942 :
3943 :
3944 0 : static gboolean bd_fs_udf_set_uuid_stub (const gchar *device G_GNUC_UNUSED, const gchar *uuid G_GNUC_UNUSED, GError **error) {
3945 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_udf_set_uuid' called, but not implemented!");
3946 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3947 : "The function 'bd_fs_udf_set_uuid' called, but not implemented!");
3948 0 : return FALSE;
3949 : }
3950 :
3951 : static gboolean (*_bd_fs_udf_set_uuid) (const gchar *device, const gchar *uuid, GError **error) = bd_fs_udf_set_uuid_stub;
3952 :
3953 : /**
3954 : * bd_fs_udf_set_uuid:
3955 : * @device: the device containing the file system to set the UUID (serial number) for
3956 : * @uuid: (nullable): UUID to set or %NULL to generate a new one
3957 : * @error: (out) (optional): place to store error (if any)
3958 : *
3959 : * Returns: whether the UUID of the UDF file system on the @device was
3960 : * successfully set or not
3961 : *
3962 : * Tech category: %BD_FS_TECH_UDF-%BD_FS_TECH_MODE_SET_UUID
3963 : */
3964 4 : gboolean bd_fs_udf_set_uuid (const gchar *device, const gchar *uuid, GError **error) {
3965 4 : return _bd_fs_udf_set_uuid (device, uuid, error);
3966 : }
3967 :
3968 :
3969 0 : static gboolean bd_fs_udf_check_uuid_stub (const gchar *uuid G_GNUC_UNUSED, GError **error) {
3970 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_udf_check_uuid' called, but not implemented!");
3971 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3972 : "The function 'bd_fs_udf_check_uuid' called, but not implemented!");
3973 0 : return FALSE;
3974 : }
3975 :
3976 : static gboolean (*_bd_fs_udf_check_uuid) (const gchar *uuid, GError **error) = bd_fs_udf_check_uuid_stub;
3977 :
3978 : /**
3979 : * bd_fs_udf_check_uuid:
3980 : * @uuid: UUID to check
3981 : * @error: (out) (optional): place to store error
3982 : *
3983 : * Returns: whether @uuid is a valid UUID for the UDF file system or not
3984 : * (reason is provided in @error)
3985 : *
3986 : * Tech category: always available
3987 : */
3988 5 : gboolean bd_fs_udf_check_uuid (const gchar *uuid, GError **error) {
3989 5 : return _bd_fs_udf_check_uuid (uuid, error);
3990 : }
3991 :
3992 :
3993 0 : static BDFSUdfInfo* bd_fs_udf_get_info_stub (const gchar *device G_GNUC_UNUSED, GError **error) {
3994 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_udf_get_info' called, but not implemented!");
3995 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
3996 : "The function 'bd_fs_udf_get_info' called, but not implemented!");
3997 0 : return NULL;
3998 : }
3999 :
4000 : static BDFSUdfInfo* (*_bd_fs_udf_get_info) (const gchar *device, GError **error) = bd_fs_udf_get_info_stub;
4001 :
4002 : /**
4003 : * bd_fs_udf_get_info:
4004 : * @device: the device containing the file system to get info for
4005 : * @error: (out) (optional): place to store error (if any)
4006 : *
4007 : * Returns: (transfer full): information about the file system on @device or
4008 : * %NULL in case of error
4009 : *
4010 : * Tech category: %BD_FS_TECH_UDF-%BD_FS_TECH_MODE_QUERY
4011 : */
4012 14 : BDFSUdfInfo* bd_fs_udf_get_info (const gchar *device, GError **error) {
4013 14 : return _bd_fs_udf_get_info (device, error);
4014 : }
4015 :
4016 :
4017 0 : static const BDFSFeatures* bd_fs_features_stub (const gchar *fstype G_GNUC_UNUSED, GError **error) {
4018 0 : bd_utils_log_format (BD_UTILS_LOG_CRIT, "The function 'bd_fs_features' called, but not implemented!");
4019 0 : g_set_error (error, BD_INIT_ERROR, BD_INIT_ERROR_NOT_IMPLEMENTED,
4020 : "The function 'bd_fs_features' called, but not implemented!");
4021 0 : return NULL;
4022 : }
4023 :
4024 : static const BDFSFeatures* (*_bd_fs_features) (const gchar *fstype, GError **error) = bd_fs_features_stub;
4025 :
4026 : /**
4027 : * bd_fs_features:
4028 : * @fstype: name of the filesystem to get features for (e.g. "ext4")
4029 : * @error: (allow-none): (out): place to store error (if any)
4030 : *
4031 : * Returns (transfer-none): features supported by @fstype, see %BDFSFeatures for more information.
4032 : *
4033 : * Tech category: always available
4034 : *
4035 : */
4036 11 : const BDFSFeatures* bd_fs_features (const gchar *fstype, GError **error) {
4037 11 : return _bd_fs_features (fstype, error);
4038 : }
4039 :
4040 :
4041 102 : static gpointer load_fs_from_plugin(const gchar *so_name) {
4042 102 : void *handle = NULL;
4043 102 : char *error = NULL;
4044 102 : gboolean (*init_fn) (void) = NULL;
4045 :
4046 102 : handle = dlopen(so_name, RTLD_LAZY);
4047 102 : if (!handle) {
4048 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load module fs: %s", dlerror());
4049 0 : return NULL;
4050 : }
4051 :
4052 102 : dlerror();
4053 102 : * (void**) (&init_fn) = dlsym(handle, "bd_fs_init");
4054 102 : if ((error = dlerror()) != NULL)
4055 0 : bd_utils_log_format (BD_UTILS_LOG_DEBUG, "failed to load the init() function for fs: %s", error);
4056 : /* coverity[dead_error_condition] */
4057 102 : if (init_fn && !init_fn()) {
4058 0 : dlclose(handle);
4059 0 : return NULL;
4060 : }
4061 102 : init_fn = NULL;
4062 :
4063 102 : dlerror();
4064 102 : * (void**) (&_bd_fs_is_tech_avail) = dlsym(handle, "bd_fs_is_tech_avail");
4065 102 : if ((error = dlerror()) != NULL)
4066 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_is_tech_avail: %s", error);
4067 :
4068 102 : dlerror();
4069 102 : * (void**) (&_bd_fs_supported_filesystems) = dlsym(handle, "bd_fs_supported_filesystems");
4070 102 : if ((error = dlerror()) != NULL)
4071 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_supported_filesystems: %s", error);
4072 :
4073 102 : dlerror();
4074 102 : * (void**) (&_bd_fs_wipe) = dlsym(handle, "bd_fs_wipe");
4075 102 : if ((error = dlerror()) != NULL)
4076 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_wipe: %s", error);
4077 :
4078 102 : dlerror();
4079 102 : * (void**) (&_bd_fs_clean) = dlsym(handle, "bd_fs_clean");
4080 102 : if ((error = dlerror()) != NULL)
4081 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_clean: %s", error);
4082 :
4083 102 : dlerror();
4084 102 : * (void**) (&_bd_fs_get_fstype) = dlsym(handle, "bd_fs_get_fstype");
4085 102 : if ((error = dlerror()) != NULL)
4086 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_get_fstype: %s", error);
4087 :
4088 102 : dlerror();
4089 102 : * (void**) (&_bd_fs_freeze) = dlsym(handle, "bd_fs_freeze");
4090 102 : if ((error = dlerror()) != NULL)
4091 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_freeze: %s", error);
4092 :
4093 102 : dlerror();
4094 102 : * (void**) (&_bd_fs_unfreeze) = dlsym(handle, "bd_fs_unfreeze");
4095 102 : if ((error = dlerror()) != NULL)
4096 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_unfreeze: %s", error);
4097 :
4098 102 : dlerror();
4099 102 : * (void**) (&_bd_fs_unmount) = dlsym(handle, "bd_fs_unmount");
4100 102 : if ((error = dlerror()) != NULL)
4101 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_unmount: %s", error);
4102 :
4103 102 : dlerror();
4104 102 : * (void**) (&_bd_fs_mount) = dlsym(handle, "bd_fs_mount");
4105 102 : if ((error = dlerror()) != NULL)
4106 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_mount: %s", error);
4107 :
4108 102 : dlerror();
4109 102 : * (void**) (&_bd_fs_get_mountpoint) = dlsym(handle, "bd_fs_get_mountpoint");
4110 102 : if ((error = dlerror()) != NULL)
4111 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_get_mountpoint: %s", error);
4112 :
4113 102 : dlerror();
4114 102 : * (void**) (&_bd_fs_is_mountpoint) = dlsym(handle, "bd_fs_is_mountpoint");
4115 102 : if ((error = dlerror()) != NULL)
4116 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_is_mountpoint: %s", error);
4117 :
4118 102 : dlerror();
4119 102 : * (void**) (&_bd_fs_resize) = dlsym(handle, "bd_fs_resize");
4120 102 : if ((error = dlerror()) != NULL)
4121 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_resize: %s", error);
4122 :
4123 102 : dlerror();
4124 102 : * (void**) (&_bd_fs_repair) = dlsym(handle, "bd_fs_repair");
4125 102 : if ((error = dlerror()) != NULL)
4126 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_repair: %s", error);
4127 :
4128 102 : dlerror();
4129 102 : * (void**) (&_bd_fs_check) = dlsym(handle, "bd_fs_check");
4130 102 : if ((error = dlerror()) != NULL)
4131 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_check: %s", error);
4132 :
4133 102 : dlerror();
4134 102 : * (void**) (&_bd_fs_check_label) = dlsym(handle, "bd_fs_check_label");
4135 102 : if ((error = dlerror()) != NULL)
4136 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_check_label: %s", error);
4137 :
4138 102 : dlerror();
4139 102 : * (void**) (&_bd_fs_set_label) = dlsym(handle, "bd_fs_set_label");
4140 102 : if ((error = dlerror()) != NULL)
4141 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_set_label: %s", error);
4142 :
4143 102 : dlerror();
4144 102 : * (void**) (&_bd_fs_check_uuid) = dlsym(handle, "bd_fs_check_uuid");
4145 102 : if ((error = dlerror()) != NULL)
4146 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_check_uuid: %s", error);
4147 :
4148 102 : dlerror();
4149 102 : * (void**) (&_bd_fs_set_uuid) = dlsym(handle, "bd_fs_set_uuid");
4150 102 : if ((error = dlerror()) != NULL)
4151 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_set_uuid: %s", error);
4152 :
4153 102 : dlerror();
4154 102 : * (void**) (&_bd_fs_xfs_check_uuid) = dlsym(handle, "bd_fs_xfs_check_uuid");
4155 102 : if ((error = dlerror()) != NULL)
4156 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_xfs_check_uuid: %s", error);
4157 :
4158 102 : dlerror();
4159 102 : * (void**) (&_bd_fs_get_size) = dlsym(handle, "bd_fs_get_size");
4160 102 : if ((error = dlerror()) != NULL)
4161 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_get_size: %s", error);
4162 :
4163 102 : dlerror();
4164 102 : * (void**) (&_bd_fs_get_free_space) = dlsym(handle, "bd_fs_get_free_space");
4165 102 : if ((error = dlerror()) != NULL)
4166 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_get_free_space: %s", error);
4167 :
4168 102 : dlerror();
4169 102 : * (void**) (&_bd_fs_get_min_size) = dlsym(handle, "bd_fs_get_min_size");
4170 102 : if ((error = dlerror()) != NULL)
4171 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_get_min_size: %s", error);
4172 :
4173 102 : dlerror();
4174 102 : * (void**) (&_bd_fs_can_get_info) = dlsym(handle, "bd_fs_can_get_info");
4175 102 : if ((error = dlerror()) != NULL)
4176 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_can_get_info: %s", error);
4177 :
4178 102 : dlerror();
4179 102 : * (void**) (&_bd_fs_can_mkfs) = dlsym(handle, "bd_fs_can_mkfs");
4180 102 : if ((error = dlerror()) != NULL)
4181 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_can_mkfs: %s", error);
4182 :
4183 102 : dlerror();
4184 102 : * (void**) (&_bd_fs_can_resize) = dlsym(handle, "bd_fs_can_resize");
4185 102 : if ((error = dlerror()) != NULL)
4186 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_can_resize: %s", error);
4187 :
4188 102 : dlerror();
4189 102 : * (void**) (&_bd_fs_can_check) = dlsym(handle, "bd_fs_can_check");
4190 102 : if ((error = dlerror()) != NULL)
4191 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_can_check: %s", error);
4192 :
4193 102 : dlerror();
4194 102 : * (void**) (&_bd_fs_can_repair) = dlsym(handle, "bd_fs_can_repair");
4195 102 : if ((error = dlerror()) != NULL)
4196 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_can_repair: %s", error);
4197 :
4198 102 : dlerror();
4199 102 : * (void**) (&_bd_fs_can_set_label) = dlsym(handle, "bd_fs_can_set_label");
4200 102 : if ((error = dlerror()) != NULL)
4201 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_can_set_label: %s", error);
4202 :
4203 102 : dlerror();
4204 102 : * (void**) (&_bd_fs_can_set_uuid) = dlsym(handle, "bd_fs_can_set_uuid");
4205 102 : if ((error = dlerror()) != NULL)
4206 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_can_set_uuid: %s", error);
4207 :
4208 102 : dlerror();
4209 102 : * (void**) (&_bd_fs_can_get_size) = dlsym(handle, "bd_fs_can_get_size");
4210 102 : if ((error = dlerror()) != NULL)
4211 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_can_get_size: %s", error);
4212 :
4213 102 : dlerror();
4214 102 : * (void**) (&_bd_fs_can_get_free_space) = dlsym(handle, "bd_fs_can_get_free_space");
4215 102 : if ((error = dlerror()) != NULL)
4216 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_can_get_free_space: %s", error);
4217 :
4218 102 : dlerror();
4219 102 : * (void**) (&_bd_fs_can_get_min_size) = dlsym(handle, "bd_fs_can_get_min_size");
4220 102 : if ((error = dlerror()) != NULL)
4221 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_can_get_min_size: %s", error);
4222 :
4223 102 : dlerror();
4224 102 : * (void**) (&_bd_fs_mkfs) = dlsym(handle, "bd_fs_mkfs");
4225 102 : if ((error = dlerror()) != NULL)
4226 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_mkfs: %s", error);
4227 :
4228 102 : dlerror();
4229 102 : * (void**) (&_bd_fs_ext2_mkfs) = dlsym(handle, "bd_fs_ext2_mkfs");
4230 102 : if ((error = dlerror()) != NULL)
4231 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext2_mkfs: %s", error);
4232 :
4233 102 : dlerror();
4234 102 : * (void**) (&_bd_fs_ext3_mkfs) = dlsym(handle, "bd_fs_ext3_mkfs");
4235 102 : if ((error = dlerror()) != NULL)
4236 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext3_mkfs: %s", error);
4237 :
4238 102 : dlerror();
4239 102 : * (void**) (&_bd_fs_ext4_mkfs) = dlsym(handle, "bd_fs_ext4_mkfs");
4240 102 : if ((error = dlerror()) != NULL)
4241 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext4_mkfs: %s", error);
4242 :
4243 102 : dlerror();
4244 102 : * (void**) (&_bd_fs_ext2_check) = dlsym(handle, "bd_fs_ext2_check");
4245 102 : if ((error = dlerror()) != NULL)
4246 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext2_check: %s", error);
4247 :
4248 102 : dlerror();
4249 102 : * (void**) (&_bd_fs_ext3_check) = dlsym(handle, "bd_fs_ext3_check");
4250 102 : if ((error = dlerror()) != NULL)
4251 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext3_check: %s", error);
4252 :
4253 102 : dlerror();
4254 102 : * (void**) (&_bd_fs_ext4_check) = dlsym(handle, "bd_fs_ext4_check");
4255 102 : if ((error = dlerror()) != NULL)
4256 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext4_check: %s", error);
4257 :
4258 102 : dlerror();
4259 102 : * (void**) (&_bd_fs_ext2_repair) = dlsym(handle, "bd_fs_ext2_repair");
4260 102 : if ((error = dlerror()) != NULL)
4261 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext2_repair: %s", error);
4262 :
4263 102 : dlerror();
4264 102 : * (void**) (&_bd_fs_ext3_repair) = dlsym(handle, "bd_fs_ext3_repair");
4265 102 : if ((error = dlerror()) != NULL)
4266 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext3_repair: %s", error);
4267 :
4268 102 : dlerror();
4269 102 : * (void**) (&_bd_fs_ext4_repair) = dlsym(handle, "bd_fs_ext4_repair");
4270 102 : if ((error = dlerror()) != NULL)
4271 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext4_repair: %s", error);
4272 :
4273 102 : dlerror();
4274 102 : * (void**) (&_bd_fs_ext2_set_label) = dlsym(handle, "bd_fs_ext2_set_label");
4275 102 : if ((error = dlerror()) != NULL)
4276 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext2_set_label: %s", error);
4277 :
4278 102 : dlerror();
4279 102 : * (void**) (&_bd_fs_ext3_set_label) = dlsym(handle, "bd_fs_ext3_set_label");
4280 102 : if ((error = dlerror()) != NULL)
4281 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext3_set_label: %s", error);
4282 :
4283 102 : dlerror();
4284 102 : * (void**) (&_bd_fs_ext4_set_label) = dlsym(handle, "bd_fs_ext4_set_label");
4285 102 : if ((error = dlerror()) != NULL)
4286 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext4_set_label: %s", error);
4287 :
4288 102 : dlerror();
4289 102 : * (void**) (&_bd_fs_ext2_check_label) = dlsym(handle, "bd_fs_ext2_check_label");
4290 102 : if ((error = dlerror()) != NULL)
4291 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext2_check_label: %s", error);
4292 :
4293 102 : dlerror();
4294 102 : * (void**) (&_bd_fs_ext3_check_label) = dlsym(handle, "bd_fs_ext3_check_label");
4295 102 : if ((error = dlerror()) != NULL)
4296 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext3_check_label: %s", error);
4297 :
4298 102 : dlerror();
4299 102 : * (void**) (&_bd_fs_ext4_check_label) = dlsym(handle, "bd_fs_ext4_check_label");
4300 102 : if ((error = dlerror()) != NULL)
4301 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext4_check_label: %s", error);
4302 :
4303 102 : dlerror();
4304 102 : * (void**) (&_bd_fs_ext2_set_uuid) = dlsym(handle, "bd_fs_ext2_set_uuid");
4305 102 : if ((error = dlerror()) != NULL)
4306 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext2_set_uuid: %s", error);
4307 :
4308 102 : dlerror();
4309 102 : * (void**) (&_bd_fs_ext3_set_uuid) = dlsym(handle, "bd_fs_ext3_set_uuid");
4310 102 : if ((error = dlerror()) != NULL)
4311 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext3_set_uuid: %s", error);
4312 :
4313 102 : dlerror();
4314 102 : * (void**) (&_bd_fs_ext4_set_uuid) = dlsym(handle, "bd_fs_ext4_set_uuid");
4315 102 : if ((error = dlerror()) != NULL)
4316 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext4_set_uuid: %s", error);
4317 :
4318 102 : dlerror();
4319 102 : * (void**) (&_bd_fs_ext2_check_uuid) = dlsym(handle, "bd_fs_ext2_check_uuid");
4320 102 : if ((error = dlerror()) != NULL)
4321 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext2_check_uuid: %s", error);
4322 :
4323 102 : dlerror();
4324 102 : * (void**) (&_bd_fs_ext3_check_uuid) = dlsym(handle, "bd_fs_ext3_check_uuid");
4325 102 : if ((error = dlerror()) != NULL)
4326 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext3_check_uuid: %s", error);
4327 :
4328 102 : dlerror();
4329 102 : * (void**) (&_bd_fs_ext4_check_uuid) = dlsym(handle, "bd_fs_ext4_check_uuid");
4330 102 : if ((error = dlerror()) != NULL)
4331 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext4_check_uuid: %s", error);
4332 :
4333 102 : dlerror();
4334 102 : * (void**) (&_bd_fs_ext2_get_info) = dlsym(handle, "bd_fs_ext2_get_info");
4335 102 : if ((error = dlerror()) != NULL)
4336 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext2_get_info: %s", error);
4337 :
4338 102 : dlerror();
4339 102 : * (void**) (&_bd_fs_ext3_get_info) = dlsym(handle, "bd_fs_ext3_get_info");
4340 102 : if ((error = dlerror()) != NULL)
4341 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext3_get_info: %s", error);
4342 :
4343 102 : dlerror();
4344 102 : * (void**) (&_bd_fs_ext4_get_info) = dlsym(handle, "bd_fs_ext4_get_info");
4345 102 : if ((error = dlerror()) != NULL)
4346 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext4_get_info: %s", error);
4347 :
4348 102 : dlerror();
4349 102 : * (void**) (&_bd_fs_ext2_resize) = dlsym(handle, "bd_fs_ext2_resize");
4350 102 : if ((error = dlerror()) != NULL)
4351 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext2_resize: %s", error);
4352 :
4353 102 : dlerror();
4354 102 : * (void**) (&_bd_fs_ext3_resize) = dlsym(handle, "bd_fs_ext3_resize");
4355 102 : if ((error = dlerror()) != NULL)
4356 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext3_resize: %s", error);
4357 :
4358 102 : dlerror();
4359 102 : * (void**) (&_bd_fs_ext4_resize) = dlsym(handle, "bd_fs_ext4_resize");
4360 102 : if ((error = dlerror()) != NULL)
4361 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext4_resize: %s", error);
4362 :
4363 102 : dlerror();
4364 102 : * (void**) (&_bd_fs_ext2_get_min_size) = dlsym(handle, "bd_fs_ext2_get_min_size");
4365 102 : if ((error = dlerror()) != NULL)
4366 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext2_get_min_size: %s", error);
4367 :
4368 102 : dlerror();
4369 102 : * (void**) (&_bd_fs_ext3_get_min_size) = dlsym(handle, "bd_fs_ext3_get_min_size");
4370 102 : if ((error = dlerror()) != NULL)
4371 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext3_get_min_size: %s", error);
4372 :
4373 102 : dlerror();
4374 102 : * (void**) (&_bd_fs_ext4_get_min_size) = dlsym(handle, "bd_fs_ext4_get_min_size");
4375 102 : if ((error = dlerror()) != NULL)
4376 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ext4_get_min_size: %s", error);
4377 :
4378 102 : dlerror();
4379 102 : * (void**) (&_bd_fs_xfs_mkfs) = dlsym(handle, "bd_fs_xfs_mkfs");
4380 102 : if ((error = dlerror()) != NULL)
4381 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_xfs_mkfs: %s", error);
4382 :
4383 102 : dlerror();
4384 102 : * (void**) (&_bd_fs_xfs_check) = dlsym(handle, "bd_fs_xfs_check");
4385 102 : if ((error = dlerror()) != NULL)
4386 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_xfs_check: %s", error);
4387 :
4388 102 : dlerror();
4389 102 : * (void**) (&_bd_fs_xfs_repair) = dlsym(handle, "bd_fs_xfs_repair");
4390 102 : if ((error = dlerror()) != NULL)
4391 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_xfs_repair: %s", error);
4392 :
4393 102 : dlerror();
4394 102 : * (void**) (&_bd_fs_xfs_set_label) = dlsym(handle, "bd_fs_xfs_set_label");
4395 102 : if ((error = dlerror()) != NULL)
4396 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_xfs_set_label: %s", error);
4397 :
4398 102 : dlerror();
4399 102 : * (void**) (&_bd_fs_xfs_check_label) = dlsym(handle, "bd_fs_xfs_check_label");
4400 102 : if ((error = dlerror()) != NULL)
4401 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_xfs_check_label: %s", error);
4402 :
4403 102 : dlerror();
4404 102 : * (void**) (&_bd_fs_xfs_set_uuid) = dlsym(handle, "bd_fs_xfs_set_uuid");
4405 102 : if ((error = dlerror()) != NULL)
4406 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_xfs_set_uuid: %s", error);
4407 :
4408 102 : dlerror();
4409 102 : * (void**) (&_bd_fs_xfs_get_info) = dlsym(handle, "bd_fs_xfs_get_info");
4410 102 : if ((error = dlerror()) != NULL)
4411 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_xfs_get_info: %s", error);
4412 :
4413 102 : dlerror();
4414 102 : * (void**) (&_bd_fs_xfs_resize) = dlsym(handle, "bd_fs_xfs_resize");
4415 102 : if ((error = dlerror()) != NULL)
4416 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_xfs_resize: %s", error);
4417 :
4418 102 : dlerror();
4419 102 : * (void**) (&_bd_fs_vfat_mkfs) = dlsym(handle, "bd_fs_vfat_mkfs");
4420 102 : if ((error = dlerror()) != NULL)
4421 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_vfat_mkfs: %s", error);
4422 :
4423 102 : dlerror();
4424 102 : * (void**) (&_bd_fs_vfat_check) = dlsym(handle, "bd_fs_vfat_check");
4425 102 : if ((error = dlerror()) != NULL)
4426 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_vfat_check: %s", error);
4427 :
4428 102 : dlerror();
4429 102 : * (void**) (&_bd_fs_vfat_repair) = dlsym(handle, "bd_fs_vfat_repair");
4430 102 : if ((error = dlerror()) != NULL)
4431 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_vfat_repair: %s", error);
4432 :
4433 102 : dlerror();
4434 102 : * (void**) (&_bd_fs_vfat_set_label) = dlsym(handle, "bd_fs_vfat_set_label");
4435 102 : if ((error = dlerror()) != NULL)
4436 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_vfat_set_label: %s", error);
4437 :
4438 102 : dlerror();
4439 102 : * (void**) (&_bd_fs_vfat_check_label) = dlsym(handle, "bd_fs_vfat_check_label");
4440 102 : if ((error = dlerror()) != NULL)
4441 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_vfat_check_label: %s", error);
4442 :
4443 102 : dlerror();
4444 102 : * (void**) (&_bd_fs_vfat_set_uuid) = dlsym(handle, "bd_fs_vfat_set_uuid");
4445 102 : if ((error = dlerror()) != NULL)
4446 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_vfat_set_uuid: %s", error);
4447 :
4448 102 : dlerror();
4449 102 : * (void**) (&_bd_fs_vfat_check_uuid) = dlsym(handle, "bd_fs_vfat_check_uuid");
4450 102 : if ((error = dlerror()) != NULL)
4451 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_vfat_check_uuid: %s", error);
4452 :
4453 102 : dlerror();
4454 102 : * (void**) (&_bd_fs_vfat_get_info) = dlsym(handle, "bd_fs_vfat_get_info");
4455 102 : if ((error = dlerror()) != NULL)
4456 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_vfat_get_info: %s", error);
4457 :
4458 102 : dlerror();
4459 102 : * (void**) (&_bd_fs_vfat_resize) = dlsym(handle, "bd_fs_vfat_resize");
4460 102 : if ((error = dlerror()) != NULL)
4461 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_vfat_resize: %s", error);
4462 :
4463 102 : dlerror();
4464 102 : * (void**) (&_bd_fs_ntfs_mkfs) = dlsym(handle, "bd_fs_ntfs_mkfs");
4465 102 : if ((error = dlerror()) != NULL)
4466 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ntfs_mkfs: %s", error);
4467 :
4468 102 : dlerror();
4469 102 : * (void**) (&_bd_fs_ntfs_check) = dlsym(handle, "bd_fs_ntfs_check");
4470 102 : if ((error = dlerror()) != NULL)
4471 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ntfs_check: %s", error);
4472 :
4473 102 : dlerror();
4474 102 : * (void**) (&_bd_fs_ntfs_repair) = dlsym(handle, "bd_fs_ntfs_repair");
4475 102 : if ((error = dlerror()) != NULL)
4476 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ntfs_repair: %s", error);
4477 :
4478 102 : dlerror();
4479 102 : * (void**) (&_bd_fs_ntfs_set_label) = dlsym(handle, "bd_fs_ntfs_set_label");
4480 102 : if ((error = dlerror()) != NULL)
4481 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ntfs_set_label: %s", error);
4482 :
4483 102 : dlerror();
4484 102 : * (void**) (&_bd_fs_ntfs_check_label) = dlsym(handle, "bd_fs_ntfs_check_label");
4485 102 : if ((error = dlerror()) != NULL)
4486 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ntfs_check_label: %s", error);
4487 :
4488 102 : dlerror();
4489 102 : * (void**) (&_bd_fs_ntfs_set_uuid) = dlsym(handle, "bd_fs_ntfs_set_uuid");
4490 102 : if ((error = dlerror()) != NULL)
4491 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ntfs_set_uuid: %s", error);
4492 :
4493 102 : dlerror();
4494 102 : * (void**) (&_bd_fs_ntfs_check_uuid) = dlsym(handle, "bd_fs_ntfs_check_uuid");
4495 102 : if ((error = dlerror()) != NULL)
4496 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ntfs_check_uuid: %s", error);
4497 :
4498 102 : dlerror();
4499 102 : * (void**) (&_bd_fs_ntfs_resize) = dlsym(handle, "bd_fs_ntfs_resize");
4500 102 : if ((error = dlerror()) != NULL)
4501 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ntfs_resize: %s", error);
4502 :
4503 102 : dlerror();
4504 102 : * (void**) (&_bd_fs_ntfs_get_info) = dlsym(handle, "bd_fs_ntfs_get_info");
4505 102 : if ((error = dlerror()) != NULL)
4506 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ntfs_get_info: %s", error);
4507 :
4508 102 : dlerror();
4509 102 : * (void**) (&_bd_fs_ntfs_get_min_size) = dlsym(handle, "bd_fs_ntfs_get_min_size");
4510 102 : if ((error = dlerror()) != NULL)
4511 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_ntfs_get_min_size: %s", error);
4512 :
4513 102 : dlerror();
4514 102 : * (void**) (&_bd_fs_f2fs_mkfs) = dlsym(handle, "bd_fs_f2fs_mkfs");
4515 102 : if ((error = dlerror()) != NULL)
4516 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_f2fs_mkfs: %s", error);
4517 :
4518 102 : dlerror();
4519 102 : * (void**) (&_bd_fs_f2fs_check) = dlsym(handle, "bd_fs_f2fs_check");
4520 102 : if ((error = dlerror()) != NULL)
4521 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_f2fs_check: %s", error);
4522 :
4523 102 : dlerror();
4524 102 : * (void**) (&_bd_fs_f2fs_repair) = dlsym(handle, "bd_fs_f2fs_repair");
4525 102 : if ((error = dlerror()) != NULL)
4526 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_f2fs_repair: %s", error);
4527 :
4528 102 : dlerror();
4529 102 : * (void**) (&_bd_fs_f2fs_get_info) = dlsym(handle, "bd_fs_f2fs_get_info");
4530 102 : if ((error = dlerror()) != NULL)
4531 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_f2fs_get_info: %s", error);
4532 :
4533 102 : dlerror();
4534 102 : * (void**) (&_bd_fs_f2fs_resize) = dlsym(handle, "bd_fs_f2fs_resize");
4535 102 : if ((error = dlerror()) != NULL)
4536 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_f2fs_resize: %s", error);
4537 :
4538 102 : dlerror();
4539 102 : * (void**) (&_bd_fs_f2fs_check_label) = dlsym(handle, "bd_fs_f2fs_check_label");
4540 102 : if ((error = dlerror()) != NULL)
4541 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_f2fs_check_label: %s", error);
4542 :
4543 102 : dlerror();
4544 102 : * (void**) (&_bd_fs_nilfs2_mkfs) = dlsym(handle, "bd_fs_nilfs2_mkfs");
4545 102 : if ((error = dlerror()) != NULL)
4546 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_nilfs2_mkfs: %s", error);
4547 :
4548 102 : dlerror();
4549 102 : * (void**) (&_bd_fs_nilfs2_set_label) = dlsym(handle, "bd_fs_nilfs2_set_label");
4550 102 : if ((error = dlerror()) != NULL)
4551 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_nilfs2_set_label: %s", error);
4552 :
4553 102 : dlerror();
4554 102 : * (void**) (&_bd_fs_nilfs2_check_label) = dlsym(handle, "bd_fs_nilfs2_check_label");
4555 102 : if ((error = dlerror()) != NULL)
4556 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_nilfs2_check_label: %s", error);
4557 :
4558 102 : dlerror();
4559 102 : * (void**) (&_bd_fs_nilfs2_set_uuid) = dlsym(handle, "bd_fs_nilfs2_set_uuid");
4560 102 : if ((error = dlerror()) != NULL)
4561 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_nilfs2_set_uuid: %s", error);
4562 :
4563 102 : dlerror();
4564 102 : * (void**) (&_bd_fs_nilfs2_check_uuid) = dlsym(handle, "bd_fs_nilfs2_check_uuid");
4565 102 : if ((error = dlerror()) != NULL)
4566 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_nilfs2_check_uuid: %s", error);
4567 :
4568 102 : dlerror();
4569 102 : * (void**) (&_bd_fs_nilfs2_get_info) = dlsym(handle, "bd_fs_nilfs2_get_info");
4570 102 : if ((error = dlerror()) != NULL)
4571 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_nilfs2_get_info: %s", error);
4572 :
4573 102 : dlerror();
4574 102 : * (void**) (&_bd_fs_nilfs2_resize) = dlsym(handle, "bd_fs_nilfs2_resize");
4575 102 : if ((error = dlerror()) != NULL)
4576 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_nilfs2_resize: %s", error);
4577 :
4578 102 : dlerror();
4579 102 : * (void**) (&_bd_fs_exfat_mkfs) = dlsym(handle, "bd_fs_exfat_mkfs");
4580 102 : if ((error = dlerror()) != NULL)
4581 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_exfat_mkfs: %s", error);
4582 :
4583 102 : dlerror();
4584 102 : * (void**) (&_bd_fs_exfat_check) = dlsym(handle, "bd_fs_exfat_check");
4585 102 : if ((error = dlerror()) != NULL)
4586 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_exfat_check: %s", error);
4587 :
4588 102 : dlerror();
4589 102 : * (void**) (&_bd_fs_exfat_repair) = dlsym(handle, "bd_fs_exfat_repair");
4590 102 : if ((error = dlerror()) != NULL)
4591 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_exfat_repair: %s", error);
4592 :
4593 102 : dlerror();
4594 102 : * (void**) (&_bd_fs_exfat_set_label) = dlsym(handle, "bd_fs_exfat_set_label");
4595 102 : if ((error = dlerror()) != NULL)
4596 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_exfat_set_label: %s", error);
4597 :
4598 102 : dlerror();
4599 102 : * (void**) (&_bd_fs_exfat_check_label) = dlsym(handle, "bd_fs_exfat_check_label");
4600 102 : if ((error = dlerror()) != NULL)
4601 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_exfat_check_label: %s", error);
4602 :
4603 102 : dlerror();
4604 102 : * (void**) (&_bd_fs_exfat_set_uuid) = dlsym(handle, "bd_fs_exfat_set_uuid");
4605 102 : if ((error = dlerror()) != NULL)
4606 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_exfat_set_uuid: %s", error);
4607 :
4608 102 : dlerror();
4609 102 : * (void**) (&_bd_fs_exfat_check_uuid) = dlsym(handle, "bd_fs_exfat_check_uuid");
4610 102 : if ((error = dlerror()) != NULL)
4611 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_exfat_check_uuid: %s", error);
4612 :
4613 102 : dlerror();
4614 102 : * (void**) (&_bd_fs_exfat_get_info) = dlsym(handle, "bd_fs_exfat_get_info");
4615 102 : if ((error = dlerror()) != NULL)
4616 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_exfat_get_info: %s", error);
4617 :
4618 102 : dlerror();
4619 102 : * (void**) (&_bd_fs_btrfs_mkfs) = dlsym(handle, "bd_fs_btrfs_mkfs");
4620 102 : if ((error = dlerror()) != NULL)
4621 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_btrfs_mkfs: %s", error);
4622 :
4623 102 : dlerror();
4624 102 : * (void**) (&_bd_fs_btrfs_check) = dlsym(handle, "bd_fs_btrfs_check");
4625 102 : if ((error = dlerror()) != NULL)
4626 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_btrfs_check: %s", error);
4627 :
4628 102 : dlerror();
4629 102 : * (void**) (&_bd_fs_btrfs_repair) = dlsym(handle, "bd_fs_btrfs_repair");
4630 102 : if ((error = dlerror()) != NULL)
4631 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_btrfs_repair: %s", error);
4632 :
4633 102 : dlerror();
4634 102 : * (void**) (&_bd_fs_btrfs_set_label) = dlsym(handle, "bd_fs_btrfs_set_label");
4635 102 : if ((error = dlerror()) != NULL)
4636 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_btrfs_set_label: %s", error);
4637 :
4638 102 : dlerror();
4639 102 : * (void**) (&_bd_fs_btrfs_check_label) = dlsym(handle, "bd_fs_btrfs_check_label");
4640 102 : if ((error = dlerror()) != NULL)
4641 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_btrfs_check_label: %s", error);
4642 :
4643 102 : dlerror();
4644 102 : * (void**) (&_bd_fs_btrfs_set_uuid) = dlsym(handle, "bd_fs_btrfs_set_uuid");
4645 102 : if ((error = dlerror()) != NULL)
4646 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_btrfs_set_uuid: %s", error);
4647 :
4648 102 : dlerror();
4649 102 : * (void**) (&_bd_fs_btrfs_check_uuid) = dlsym(handle, "bd_fs_btrfs_check_uuid");
4650 102 : if ((error = dlerror()) != NULL)
4651 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_btrfs_check_uuid: %s", error);
4652 :
4653 102 : dlerror();
4654 102 : * (void**) (&_bd_fs_btrfs_get_info) = dlsym(handle, "bd_fs_btrfs_get_info");
4655 102 : if ((error = dlerror()) != NULL)
4656 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_btrfs_get_info: %s", error);
4657 :
4658 102 : dlerror();
4659 102 : * (void**) (&_bd_fs_btrfs_resize) = dlsym(handle, "bd_fs_btrfs_resize");
4660 102 : if ((error = dlerror()) != NULL)
4661 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_btrfs_resize: %s", error);
4662 :
4663 102 : dlerror();
4664 102 : * (void**) (&_bd_fs_udf_mkfs) = dlsym(handle, "bd_fs_udf_mkfs");
4665 102 : if ((error = dlerror()) != NULL)
4666 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_udf_mkfs: %s", error);
4667 :
4668 102 : dlerror();
4669 102 : * (void**) (&_bd_fs_udf_set_label) = dlsym(handle, "bd_fs_udf_set_label");
4670 102 : if ((error = dlerror()) != NULL)
4671 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_udf_set_label: %s", error);
4672 :
4673 102 : dlerror();
4674 102 : * (void**) (&_bd_fs_udf_check_label) = dlsym(handle, "bd_fs_udf_check_label");
4675 102 : if ((error = dlerror()) != NULL)
4676 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_udf_check_label: %s", error);
4677 :
4678 102 : dlerror();
4679 102 : * (void**) (&_bd_fs_udf_set_uuid) = dlsym(handle, "bd_fs_udf_set_uuid");
4680 102 : if ((error = dlerror()) != NULL)
4681 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_udf_set_uuid: %s", error);
4682 :
4683 102 : dlerror();
4684 102 : * (void**) (&_bd_fs_udf_check_uuid) = dlsym(handle, "bd_fs_udf_check_uuid");
4685 102 : if ((error = dlerror()) != NULL)
4686 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_udf_check_uuid: %s", error);
4687 :
4688 102 : dlerror();
4689 102 : * (void**) (&_bd_fs_udf_get_info) = dlsym(handle, "bd_fs_udf_get_info");
4690 102 : if ((error = dlerror()) != NULL)
4691 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_udf_get_info: %s", error);
4692 :
4693 102 : dlerror();
4694 102 : * (void**) (&_bd_fs_features) = dlsym(handle, "bd_fs_features");
4695 102 : if ((error = dlerror()) != NULL)
4696 0 : bd_utils_log_format (BD_UTILS_LOG_WARNING, "failed to load bd_fs_features: %s", error);
4697 :
4698 102 : return handle;
4699 : }
4700 :
4701 102 : static gboolean unload_fs (gpointer handle) {
4702 102 : char *error = NULL;
4703 102 : gboolean (*close_fn) (void) = NULL;
4704 :
4705 102 : _bd_fs_is_tech_avail = bd_fs_is_tech_avail_stub;
4706 102 : _bd_fs_supported_filesystems = bd_fs_supported_filesystems_stub;
4707 102 : _bd_fs_wipe = bd_fs_wipe_stub;
4708 102 : _bd_fs_clean = bd_fs_clean_stub;
4709 102 : _bd_fs_get_fstype = bd_fs_get_fstype_stub;
4710 102 : _bd_fs_freeze = bd_fs_freeze_stub;
4711 102 : _bd_fs_unfreeze = bd_fs_unfreeze_stub;
4712 102 : _bd_fs_unmount = bd_fs_unmount_stub;
4713 102 : _bd_fs_mount = bd_fs_mount_stub;
4714 102 : _bd_fs_get_mountpoint = bd_fs_get_mountpoint_stub;
4715 102 : _bd_fs_is_mountpoint = bd_fs_is_mountpoint_stub;
4716 102 : _bd_fs_resize = bd_fs_resize_stub;
4717 102 : _bd_fs_repair = bd_fs_repair_stub;
4718 102 : _bd_fs_check = bd_fs_check_stub;
4719 102 : _bd_fs_check_label = bd_fs_check_label_stub;
4720 102 : _bd_fs_set_label = bd_fs_set_label_stub;
4721 102 : _bd_fs_check_uuid = bd_fs_check_uuid_stub;
4722 102 : _bd_fs_set_uuid = bd_fs_set_uuid_stub;
4723 102 : _bd_fs_xfs_check_uuid = bd_fs_xfs_check_uuid_stub;
4724 102 : _bd_fs_get_size = bd_fs_get_size_stub;
4725 102 : _bd_fs_get_free_space = bd_fs_get_free_space_stub;
4726 102 : _bd_fs_get_min_size = bd_fs_get_min_size_stub;
4727 102 : _bd_fs_can_get_info = bd_fs_can_get_info_stub;
4728 102 : _bd_fs_can_mkfs = bd_fs_can_mkfs_stub;
4729 102 : _bd_fs_can_resize = bd_fs_can_resize_stub;
4730 102 : _bd_fs_can_check = bd_fs_can_check_stub;
4731 102 : _bd_fs_can_repair = bd_fs_can_repair_stub;
4732 102 : _bd_fs_can_set_label = bd_fs_can_set_label_stub;
4733 102 : _bd_fs_can_set_uuid = bd_fs_can_set_uuid_stub;
4734 102 : _bd_fs_can_get_size = bd_fs_can_get_size_stub;
4735 102 : _bd_fs_can_get_free_space = bd_fs_can_get_free_space_stub;
4736 102 : _bd_fs_can_get_min_size = bd_fs_can_get_min_size_stub;
4737 102 : _bd_fs_mkfs = bd_fs_mkfs_stub;
4738 102 : _bd_fs_ext2_mkfs = bd_fs_ext2_mkfs_stub;
4739 102 : _bd_fs_ext3_mkfs = bd_fs_ext3_mkfs_stub;
4740 102 : _bd_fs_ext4_mkfs = bd_fs_ext4_mkfs_stub;
4741 102 : _bd_fs_ext2_check = bd_fs_ext2_check_stub;
4742 102 : _bd_fs_ext3_check = bd_fs_ext3_check_stub;
4743 102 : _bd_fs_ext4_check = bd_fs_ext4_check_stub;
4744 102 : _bd_fs_ext2_repair = bd_fs_ext2_repair_stub;
4745 102 : _bd_fs_ext3_repair = bd_fs_ext3_repair_stub;
4746 102 : _bd_fs_ext4_repair = bd_fs_ext4_repair_stub;
4747 102 : _bd_fs_ext2_set_label = bd_fs_ext2_set_label_stub;
4748 102 : _bd_fs_ext3_set_label = bd_fs_ext3_set_label_stub;
4749 102 : _bd_fs_ext4_set_label = bd_fs_ext4_set_label_stub;
4750 102 : _bd_fs_ext2_check_label = bd_fs_ext2_check_label_stub;
4751 102 : _bd_fs_ext3_check_label = bd_fs_ext3_check_label_stub;
4752 102 : _bd_fs_ext4_check_label = bd_fs_ext4_check_label_stub;
4753 102 : _bd_fs_ext2_set_uuid = bd_fs_ext2_set_uuid_stub;
4754 102 : _bd_fs_ext3_set_uuid = bd_fs_ext3_set_uuid_stub;
4755 102 : _bd_fs_ext4_set_uuid = bd_fs_ext4_set_uuid_stub;
4756 102 : _bd_fs_ext2_check_uuid = bd_fs_ext2_check_uuid_stub;
4757 102 : _bd_fs_ext3_check_uuid = bd_fs_ext3_check_uuid_stub;
4758 102 : _bd_fs_ext4_check_uuid = bd_fs_ext4_check_uuid_stub;
4759 102 : _bd_fs_ext2_get_info = bd_fs_ext2_get_info_stub;
4760 102 : _bd_fs_ext3_get_info = bd_fs_ext3_get_info_stub;
4761 102 : _bd_fs_ext4_get_info = bd_fs_ext4_get_info_stub;
4762 102 : _bd_fs_ext2_resize = bd_fs_ext2_resize_stub;
4763 102 : _bd_fs_ext3_resize = bd_fs_ext3_resize_stub;
4764 102 : _bd_fs_ext4_resize = bd_fs_ext4_resize_stub;
4765 102 : _bd_fs_ext2_get_min_size = bd_fs_ext2_get_min_size_stub;
4766 102 : _bd_fs_ext3_get_min_size = bd_fs_ext3_get_min_size_stub;
4767 102 : _bd_fs_ext4_get_min_size = bd_fs_ext4_get_min_size_stub;
4768 102 : _bd_fs_xfs_mkfs = bd_fs_xfs_mkfs_stub;
4769 102 : _bd_fs_xfs_check = bd_fs_xfs_check_stub;
4770 102 : _bd_fs_xfs_repair = bd_fs_xfs_repair_stub;
4771 102 : _bd_fs_xfs_set_label = bd_fs_xfs_set_label_stub;
4772 102 : _bd_fs_xfs_check_label = bd_fs_xfs_check_label_stub;
4773 102 : _bd_fs_xfs_set_uuid = bd_fs_xfs_set_uuid_stub;
4774 102 : _bd_fs_xfs_get_info = bd_fs_xfs_get_info_stub;
4775 102 : _bd_fs_xfs_resize = bd_fs_xfs_resize_stub;
4776 102 : _bd_fs_vfat_mkfs = bd_fs_vfat_mkfs_stub;
4777 102 : _bd_fs_vfat_check = bd_fs_vfat_check_stub;
4778 102 : _bd_fs_vfat_repair = bd_fs_vfat_repair_stub;
4779 102 : _bd_fs_vfat_set_label = bd_fs_vfat_set_label_stub;
4780 102 : _bd_fs_vfat_check_label = bd_fs_vfat_check_label_stub;
4781 102 : _bd_fs_vfat_set_uuid = bd_fs_vfat_set_uuid_stub;
4782 102 : _bd_fs_vfat_check_uuid = bd_fs_vfat_check_uuid_stub;
4783 102 : _bd_fs_vfat_get_info = bd_fs_vfat_get_info_stub;
4784 102 : _bd_fs_vfat_resize = bd_fs_vfat_resize_stub;
4785 102 : _bd_fs_ntfs_mkfs = bd_fs_ntfs_mkfs_stub;
4786 102 : _bd_fs_ntfs_check = bd_fs_ntfs_check_stub;
4787 102 : _bd_fs_ntfs_repair = bd_fs_ntfs_repair_stub;
4788 102 : _bd_fs_ntfs_set_label = bd_fs_ntfs_set_label_stub;
4789 102 : _bd_fs_ntfs_check_label = bd_fs_ntfs_check_label_stub;
4790 102 : _bd_fs_ntfs_set_uuid = bd_fs_ntfs_set_uuid_stub;
4791 102 : _bd_fs_ntfs_check_uuid = bd_fs_ntfs_check_uuid_stub;
4792 102 : _bd_fs_ntfs_resize = bd_fs_ntfs_resize_stub;
4793 102 : _bd_fs_ntfs_get_info = bd_fs_ntfs_get_info_stub;
4794 102 : _bd_fs_ntfs_get_min_size = bd_fs_ntfs_get_min_size_stub;
4795 102 : _bd_fs_f2fs_mkfs = bd_fs_f2fs_mkfs_stub;
4796 102 : _bd_fs_f2fs_check = bd_fs_f2fs_check_stub;
4797 102 : _bd_fs_f2fs_repair = bd_fs_f2fs_repair_stub;
4798 102 : _bd_fs_f2fs_get_info = bd_fs_f2fs_get_info_stub;
4799 102 : _bd_fs_f2fs_resize = bd_fs_f2fs_resize_stub;
4800 102 : _bd_fs_f2fs_check_label = bd_fs_f2fs_check_label_stub;
4801 102 : _bd_fs_nilfs2_mkfs = bd_fs_nilfs2_mkfs_stub;
4802 102 : _bd_fs_nilfs2_set_label = bd_fs_nilfs2_set_label_stub;
4803 102 : _bd_fs_nilfs2_check_label = bd_fs_nilfs2_check_label_stub;
4804 102 : _bd_fs_nilfs2_set_uuid = bd_fs_nilfs2_set_uuid_stub;
4805 102 : _bd_fs_nilfs2_check_uuid = bd_fs_nilfs2_check_uuid_stub;
4806 102 : _bd_fs_nilfs2_get_info = bd_fs_nilfs2_get_info_stub;
4807 102 : _bd_fs_nilfs2_resize = bd_fs_nilfs2_resize_stub;
4808 102 : _bd_fs_exfat_mkfs = bd_fs_exfat_mkfs_stub;
4809 102 : _bd_fs_exfat_check = bd_fs_exfat_check_stub;
4810 102 : _bd_fs_exfat_repair = bd_fs_exfat_repair_stub;
4811 102 : _bd_fs_exfat_set_label = bd_fs_exfat_set_label_stub;
4812 102 : _bd_fs_exfat_check_label = bd_fs_exfat_check_label_stub;
4813 102 : _bd_fs_exfat_set_uuid = bd_fs_exfat_set_uuid_stub;
4814 102 : _bd_fs_exfat_check_uuid = bd_fs_exfat_check_uuid_stub;
4815 102 : _bd_fs_exfat_get_info = bd_fs_exfat_get_info_stub;
4816 102 : _bd_fs_btrfs_mkfs = bd_fs_btrfs_mkfs_stub;
4817 102 : _bd_fs_btrfs_check = bd_fs_btrfs_check_stub;
4818 102 : _bd_fs_btrfs_repair = bd_fs_btrfs_repair_stub;
4819 102 : _bd_fs_btrfs_set_label = bd_fs_btrfs_set_label_stub;
4820 102 : _bd_fs_btrfs_check_label = bd_fs_btrfs_check_label_stub;
4821 102 : _bd_fs_btrfs_set_uuid = bd_fs_btrfs_set_uuid_stub;
4822 102 : _bd_fs_btrfs_check_uuid = bd_fs_btrfs_check_uuid_stub;
4823 102 : _bd_fs_btrfs_get_info = bd_fs_btrfs_get_info_stub;
4824 102 : _bd_fs_btrfs_resize = bd_fs_btrfs_resize_stub;
4825 102 : _bd_fs_udf_mkfs = bd_fs_udf_mkfs_stub;
4826 102 : _bd_fs_udf_set_label = bd_fs_udf_set_label_stub;
4827 102 : _bd_fs_udf_check_label = bd_fs_udf_check_label_stub;
4828 102 : _bd_fs_udf_set_uuid = bd_fs_udf_set_uuid_stub;
4829 102 : _bd_fs_udf_check_uuid = bd_fs_udf_check_uuid_stub;
4830 102 : _bd_fs_udf_get_info = bd_fs_udf_get_info_stub;
4831 102 : _bd_fs_features = bd_fs_features_stub;
4832 :
4833 102 : dlerror();
4834 102 : * (void**) (&close_fn) = dlsym(handle, "bd_fs_close");
4835 102 : if (((error = dlerror()) != NULL) || !close_fn)
4836 0 : bd_utils_log_format (BD_UTILS_LOG_DEBUG, "failed to load the close_plugin() function for fs: %s", error);
4837 : /* coverity[dead_error_condition] */
4838 102 : if (close_fn) {
4839 102 : close_fn();
4840 : }
4841 :
4842 102 : return dlclose(handle) == 0;
4843 : }
4844 :
|
