kpartx/devmapper.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <libdevmapper.h>
   5 #include <ctype.h>
   6 #include <linux/kdev_t.h>
   7
   8 extern int
   9 dm_prereq (char * str, int x, int y, int z)
  10 {
  11         int r = 1;
  12         struct dm_task *dmt;
  13         struct dm_versions *target;
  14         struct dm_versions *last_target;
  15
  16         if (!(dmt = dm_task_create(DM_DEVICE_LIST_VERSIONS)))
  17                 return 1;
  18
  19         dm_task_no_open_count(dmt);
  20
  21         if (!dm_task_run(dmt))
  22                 goto out;
  23
  24         target = dm_task_get_versions(dmt);
  25
  26         /* Fetch targets and print 'em */
  27         do {
  28                 last_target = target;
  29
  30                 if (!strncmp(str, target->name, strlen(str)) &&
  31                     /* dummy prereq on multipath version */
  32                     target->version[0] >= x &&
  33                     target->version[1] >= y &&
  34                     target->version[2] >= z
  35                    )
  36                         r = 0;
  37
  38                 target = (void *) target + target->next;
  39         } while (last_target != target);
  40
  41         out:
  42         dm_task_destroy(dmt);
  43         return r;
  44 }
  45
  46 extern int
  47 dm_simplecmd (int task, const char *name) {
  48         int r = 0;
  49         struct dm_task *dmt;
  50
  51         if (!(dmt = dm_task_create(task)))
  52                 return 0;
  53
  54         if (!dm_task_set_name(dmt, name))
  55                 goto out;
  56
  57         dm_task_no_open_count(dmt);
  58
  59         r = dm_task_run(dmt);
  60
  61         out:
  62         dm_task_destroy(dmt);
  63         return r;
  64 }
  65
  66 extern int
  67 dm_addmap (int task, const char *name, const char *target,
  68            const char *params, unsigned long size) {
  69         int r = 0;
  70         struct dm_task *dmt;
  71
  72         if (!(dmt = dm_task_create (task)))
  73                 return 0;
  74
  75         if (!dm_task_set_name (dmt, name))
  76                 goto addout;
  77
  78         if (!dm_task_add_target (dmt, 0, size, target, params))
  79                 goto addout;
  80
  81         dm_task_no_open_count(dmt);
  82
  83         r = dm_task_run (dmt);
  84
  85         addout:
  86         dm_task_destroy (dmt);
  87         return r;
  88 }
  89
  90 extern int
  91 dm_map_present (char * str)
  92 {
  93         int r = 0;
  94         struct dm_task *dmt;
  95         struct dm_info info;
  96
  97         if (!(dmt = dm_task_create(DM_DEVICE_INFO)))
  98                 return 0;
  99
 100         if (!dm_task_set_name(dmt, str))
 101                 goto out;
 102
 103         dm_task_no_open_count(dmt);
 104
 105         if (!dm_task_run(dmt))
 106                 goto out;
 107
 108         if (!dm_task_get_info(dmt, &info))
 109                 goto out;
 110
 111         if (info.exists)
 112                 r = 1;
 113 out:
 114         dm_task_destroy(dmt);
 115         return r;
 116 }
 117
 118
 119 const char *
 120 dm_mapname(int major, int minor)
 121 {
 122         struct dm_task *dmt;
 123         const char *mapname;
 124
 125         if (!(dmt = dm_task_create(DM_DEVICE_INFO)))
 126                 return NULL;
 127
 128         dm_task_no_open_count(dmt);
 129         dm_task_set_major(dmt, major);
 130         dm_task_set_minor(dmt, minor);
 131
 132         if (!dm_task_run(dmt))
 133                 goto out;
 134
 135         mapname = strdup(dm_task_get_name(dmt));
 136 out:
 137         dm_task_destroy(dmt);
 138         return mapname;
 139 }
 140