disk/lvm: Make cache_lv more generic as ignored_feature_lv

This patch isn't necessary by itself, but when combined with subsequent
patches it enhances readability as ignored_features_lv is then used for
multiple types of extra LV's, not just cache LV's.

Signed-off-by: Patrick Plenefisch <simonpatp@gmail.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>

diff --git a/grub-core/disk/lvm.c b/grub-core/disk/lvm.c
index d5af854825bed825247a34bb41fb5487a9366ff0..97932fe9a27e14bfcf34f70fcd39373593d1fabf 100644 (file)
--- a/grub-core/disk/lvm.c
+++ b/grub-core/disk/lvm.c
@@ -34,12 +34,12 @@
 
 GRUB_MOD_LICENSE ("GPLv3+");
 
-struct cache_lv
+struct ignored_feature_lv
 {
   struct grub_diskfilter_lv *lv;
   char *cache_pool;
   char *origin;
-  struct cache_lv *next;
+  struct ignored_feature_lv *next;
 };
 
 \f
@@ -105,30 +105,30 @@ grub_lvm_check_flag (const char *p, const char *str, const char *flag)
 }
 
 static void
-grub_lvm_free_cache_lvs (struct cache_lv *cache_lvs)
+grub_lvm_free_ignored_feature_lvs (struct ignored_feature_lv *ignored_feature_lvs)
 {
-  struct cache_lv *cache;
+  struct ignored_feature_lv *ignored_feature;
 
-  while ((cache = cache_lvs))
+  while ((ignored_feature = ignored_feature_lvs))
     {
-      cache_lvs = cache_lvs->next;
+      ignored_feature_lvs = ignored_feature_lvs->next;
 
-      if (cache->lv)
+      if (ignored_feature->lv)
        {
          unsigned int i;
 
-         for (i = 0; i < cache->lv->segment_count; ++i)
-           if (cache->lv->segments)
-             grub_free (cache->lv->segments[i].nodes);
-         grub_free (cache->lv->segments);
-         grub_free (cache->lv->fullname);
-         grub_free (cache->lv->idname);
-         grub_free (cache->lv->name);
+         for (i = 0; i < ignored_feature->lv->segment_count; ++i)
+           if (ignored_feature->lv->segments)
+             grub_free (ignored_feature->lv->segments[i].nodes);
+         grub_free (ignored_feature->lv->segments);
+         grub_free (ignored_feature->lv->fullname);
+         grub_free (ignored_feature->lv->idname);
+         grub_free (ignored_feature->lv->name);
        }
-      grub_free (cache->lv);
-      grub_free (cache->origin);
-      grub_free (cache->cache_pool);
-      grub_free (cache);
+      grub_free (ignored_feature->lv);
+      grub_free (ignored_feature->origin);
+      grub_free (ignored_feature->cache_pool);
+      grub_free (ignored_feature);
     }
 }
 
@@ -325,7 +325,7 @@ grub_lvm_detect (grub_disk_t disk,
 
   if (! vg)
     {
-      struct cache_lv *cache_lvs = NULL;
+      struct ignored_feature_lv *ignored_feature_lvs = NULL;
 
       /* First time we see this volume group. We've to create the
         whole volume group structure. */
@@ -822,105 +822,105 @@ grub_lvm_detect (grub_disk_t disk,
                  else if (grub_memcmp (p, "cache\"",
                                   sizeof ("cache\"") - 1) == 0)
                    {
-                     struct cache_lv *cache = NULL;
+                     struct ignored_feature_lv *ignored_feature = NULL;
 
                      char *p2, *p3;
                      grub_size_t sz;
 
-                     cache = grub_zalloc (sizeof (*cache));
-                     if (!cache)
-                       goto cache_lv_fail;
-                     cache->lv = grub_zalloc (sizeof (*cache->lv));
-                     if (!cache->lv)
-                       goto cache_lv_fail;
-                     grub_memcpy (cache->lv, lv, sizeof (*cache->lv));
+                     ignored_feature = grub_zalloc (sizeof (*ignored_feature));
+                     if (!ignored_feature)
+                       goto ignored_feature_lv_fail;
+                     ignored_feature->lv = grub_zalloc (sizeof (*ignored_feature->lv));
+                     if (!ignored_feature->lv)
+                       goto ignored_feature_lv_fail;
+                     grub_memcpy (ignored_feature->lv, lv, sizeof (*ignored_feature->lv));
 
                      if (lv->fullname)
                        {
-                         cache->lv->fullname = grub_strdup (lv->fullname);
-                         if (!cache->lv->fullname)
-                           goto cache_lv_fail;
+                         ignored_feature->lv->fullname = grub_strdup (lv->fullname);
+                         if (!ignored_feature->lv->fullname)
+                           goto ignored_feature_lv_fail;
                        }
                      if (lv->idname)
                        {
-                         cache->lv->idname = grub_strdup (lv->idname);
-                         if (!cache->lv->idname)
-                           goto cache_lv_fail;
+                         ignored_feature->lv->idname = grub_strdup (lv->idname);
+                         if (!ignored_feature->lv->idname)
+                           goto ignored_feature_lv_fail;
                        }
                      if (lv->name)
                        {
-                         cache->lv->name = grub_strdup (lv->name);
-                         if (!cache->lv->name)
-                           goto cache_lv_fail;
+                         ignored_feature->lv->name = grub_strdup (lv->name);
+                         if (!ignored_feature->lv->name)
+                           goto ignored_feature_lv_fail;
                        }
 
                      skip_lv = 1;
 
                      p2 = grub_strstr (p, "cache_pool = \"");
                      if (!p2)
-                       goto cache_lv_fail;
+                       goto ignored_feature_lv_fail;
 
                      p2 = grub_strchr (p2, '"');
                      if (!p2)
-                       goto cache_lv_fail;
+                       goto ignored_feature_lv_fail;
 
                      p3 = ++p2;
                      if (p3 == mda_end)
-                       goto cache_lv_fail;
+                       goto ignored_feature_lv_fail;
                      p3 = grub_strchr (p3, '"');
                      if (!p3)
-                       goto cache_lv_fail;
+                       goto ignored_feature_lv_fail;
 
                      sz = p3 - p2;
 
-                     cache->cache_pool = grub_malloc (sz + 1);
-                     if (!cache->cache_pool)
-                       goto cache_lv_fail;
-                     grub_memcpy (cache->cache_pool, p2, sz);
-                     cache->cache_pool[sz] = '\0';
+                     ignored_feature->cache_pool = grub_malloc (sz + 1);
+                     if (!ignored_feature->cache_pool)
+                       goto ignored_feature_lv_fail;
+                     grub_memcpy (ignored_feature->cache_pool, p2, sz);
+                     ignored_feature->cache_pool[sz] = '\0';
 
                      p2 = grub_strstr (p, "origin = \"");
                      if (!p2)
-                       goto cache_lv_fail;
+                       goto ignored_feature_lv_fail;
 
                      p2 = grub_strchr (p2, '"');
                      if (!p2)
-                       goto cache_lv_fail;
+                       goto ignored_feature_lv_fail;
 
                      p3 = ++p2;
                      if (p3 == mda_end)
-                       goto cache_lv_fail;
+                       goto ignored_feature_lv_fail;
                      p3 = grub_strchr (p3, '"');
                      if (!p3)
-                       goto cache_lv_fail;
+                       goto ignored_feature_lv_fail;
 
                      sz = p3 - p2;
 
-                     cache->origin = grub_malloc (sz + 1);
-                     if (!cache->origin)
-                       goto cache_lv_fail;
-                     grub_memcpy (cache->origin, p2, sz);
-                     cache->origin[sz] = '\0';
+                     ignored_feature->origin = grub_malloc (sz + 1);
+                     if (!ignored_feature->origin)
+                       goto ignored_feature_lv_fail;
+                     grub_memcpy (ignored_feature->origin, p2, sz);
+                     ignored_feature->origin[sz] = '\0';
 
-                     cache->next = cache_lvs;
-                     cache_lvs = cache;
+                     ignored_feature->next = ignored_feature_lvs;
+                     ignored_feature_lvs = ignored_feature;
                      break;
 
-                   cache_lv_fail:
-                     if (cache)
+                   ignored_feature_lv_fail:
+                     if (ignored_feature)
                        {
-                         grub_free (cache->origin);
-                         grub_free (cache->cache_pool);
-                         if (cache->lv)
+                         grub_free (ignored_feature->origin);
+                         grub_free (ignored_feature->cache_pool);
+                         if (ignored_feature->lv)
                            {
-                             grub_free (cache->lv->fullname);
-                             grub_free (cache->lv->idname);
-                             grub_free (cache->lv->name);
+                             grub_free (ignored_feature->lv->fullname);
+                             grub_free (ignored_feature->lv->idname);
+                             grub_free (ignored_feature->lv->name);
                            }
-                         grub_free (cache->lv);
-                         grub_free (cache);
+                         grub_free (ignored_feature->lv);
+                         grub_free (ignored_feature);
                        }
-                     grub_lvm_free_cache_lvs (cache_lvs);
+                     grub_lvm_free_ignored_feature_lvs (ignored_feature_lvs);
                      goto fail4;
                    }
                  else
@@ -1005,56 +1005,56 @@ grub_lvm_detect (grub_disk_t disk,
       }
 
       {
-       struct cache_lv *cache;
+       struct ignored_feature_lv *ignored_feature;
 
-       for (cache = cache_lvs; cache; cache = cache->next)
+       for (ignored_feature = ignored_feature_lvs; ignored_feature; ignored_feature = ignored_feature->next)
          {
            struct grub_diskfilter_lv *lv;
 
            for (lv = vg->lvs; lv; lv = lv->next)
-             if (grub_strcmp (lv->name, cache->origin) == 0)
+             if (grub_strcmp (lv->name, ignored_feature->origin) == 0)
                break;
            if (lv)
              {
-               cache->lv->segments = grub_calloc (lv->segment_count, sizeof (*lv->segments));
-               if (!cache->lv->segments)
+               ignored_feature->lv->segments = grub_calloc (lv->segment_count, sizeof (*lv->segments));
+               if (!ignored_feature->lv->segments)
                  {
-                   grub_lvm_free_cache_lvs (cache_lvs);
+                   grub_lvm_free_ignored_feature_lvs (ignored_feature_lvs);
                    goto fail4;
                  }
-               grub_memcpy (cache->lv->segments, lv->segments, lv->segment_count * sizeof (*lv->segments));
+               grub_memcpy (ignored_feature->lv->segments, lv->segments, lv->segment_count * sizeof (*lv->segments));
 
                for (i = 0; i < lv->segment_count; ++i)
                  {
                    struct grub_diskfilter_node *nodes = lv->segments[i].nodes;
                    grub_size_t node_count = lv->segments[i].node_count;
 
-                   cache->lv->segments[i].nodes = grub_calloc (node_count, sizeof (*nodes));
-                   if (!cache->lv->segments[i].nodes)
+                   ignored_feature->lv->segments[i].nodes = grub_calloc (node_count, sizeof (*nodes));
+                   if (!ignored_feature->lv->segments[i].nodes)
                      {
                        for (j = 0; j < i; ++j)
-                         grub_free (cache->lv->segments[j].nodes);
-                       grub_free (cache->lv->segments);
-                       cache->lv->segments = NULL;
-                       grub_lvm_free_cache_lvs (cache_lvs);
+                         grub_free (ignored_feature->lv->segments[j].nodes);
+                       grub_free (ignored_feature->lv->segments);
+                       ignored_feature->lv->segments = NULL;
+                       grub_lvm_free_ignored_feature_lvs (ignored_feature_lvs);
                        goto fail4;
                      }
-                   grub_memcpy (cache->lv->segments[i].nodes, nodes, node_count * sizeof (*nodes));
+                   grub_memcpy (ignored_feature->lv->segments[i].nodes, nodes, node_count * sizeof (*nodes));
                  }
 
-               if (cache->lv->segments)
+               if (ignored_feature->lv->segments)
                  {
-                   cache->lv->segment_count = lv->segment_count;
-                   cache->lv->vg = vg;
-                   cache->lv->next = vg->lvs;
-                   vg->lvs = cache->lv;
-                   cache->lv = NULL;
+                   ignored_feature->lv->segment_count = lv->segment_count;
+                   ignored_feature->lv->vg = vg;
+                   ignored_feature->lv->next = vg->lvs;
+                   vg->lvs = ignored_feature->lv;
+                   ignored_feature->lv = NULL;
                  }
              }
          }
       }
 
-      grub_lvm_free_cache_lvs (cache_lvs);
+         grub_lvm_free_ignored_feature_lvs (ignored_feature_lvs);
       if (grub_diskfilter_vg_register (vg))
        goto fail4;
     }