intel: Don't try to read from tiny devices.

[thirdparty/mdadm.git] / policy.c

diff --git a/policy.c b/policy.c
index abf9ee8ce3cd1e58bec689051a234c892a5ac55c..0e343b989748ee77a7913a985bc7a449508dc06a 100644 (file)
--- a/policy.c
+++ b/policy.c
@@ -459,3 +459,137 @@ void dev_policy_free(struct dev_policy *p)
                free(t);
        }
 }
+
+static enum policy_action map_act(char *act)
+{
+       if (strcmp(act, "include") == 0)
+               return act_include;
+       if (strcmp(act, "re-add") == 0)
+               return act_re_add;
+       if (strcmp(act, "spare") == 0)
+               return act_spare;
+       if (strcmp(act, "force-spare") == 0)
+               return act_force_spare;
+       return act_err;
+}
+
+static enum policy_action policy_action(struct dev_policy *plist, const char *metadata)
+{
+       enum policy_action rv = act_default;
+       struct dev_policy *p;
+
+       plist = pol_find(plist, pol_act);
+       pol_for_each(p, plist, metadata) {
+               enum policy_action a = map_act(p->value);
+               if (a > rv)
+                       rv = a;
+       }
+       return rv;
+}
+
+int policy_action_allows(struct dev_policy *plist, const char *metadata, enum policy_action want)
+{
+       enum policy_action act = policy_action(plist, metadata);
+
+       if (act == act_err)
+               return 0;
+       return (act >= want);
+}
+
+int disk_action_allows(struct mdinfo *disk, const char *metadata, enum policy_action want)
+{
+       struct dev_policy *pol = disk_policy(disk);
+       int rv = policy_action_allows(pol, metadata, want);
+
+       dev_policy_free(pol);
+       return rv;
+}
+
+
+/* Domain policy:
+ * Any device can have a list of domains asserted by different policy
+ * statements.
+ * An array also has a list of domains comprising all the domains of
+ * all the devices in an array.
+ * Where an array has a spare-group, that becomes an addition domain for
+ * every device in the array and thus for the array.
+ *
+ * We keep the list of domains in a sorted linked list
+ * As dev policies are already sorted, this is fairly easy to manage.
+ */
+
+static struct domainlist **domain_merge_one(struct domainlist **domp, char *domain)
+{
+       /* merge a domain name into a sorted list and return the
+        * location of the insertion or match
+        */
+       struct domainlist *dom = *domp;
+
+       while (dom && strcmp(dom->dom, domain) < 0) {
+               domp = &dom->next;
+               dom = *domp;
+       }
+       if (dom == NULL || strcmp(dom->dom, domain) != 0) {
+               dom = malloc(sizeof(*dom));
+               dom->next = *domp;
+               dom->dom = domain;
+               *domp = dom;
+       }
+       return domp;
+}
+
+void domain_merge(struct domainlist **domp, struct dev_policy *pollist,
+                        const char *metadata)
+{
+       /* Add to 'domp' all the domains in pol that apply to 'metadata'
+        * which are not already in domp
+        */
+       struct dev_policy *pol;
+       pollist = pol_find(pollist, pol_domain);
+       pol_for_each(pol, pollist, metadata)
+               domp = domain_merge_one(domp, pol->value);
+}
+
+int domain_test(struct domainlist *dom, struct dev_policy *pol,
+               const char *metadata)
+{
+       /* Check that all domains in pol (for metadata) are also in
+        * dom.  Both lists are sorted.
+        * If pol has no domains, we don't really know about this device
+        * so we reject the match.
+        */
+       int found_any = 0;
+       struct dev_policy *p;
+
+       pol = pol_find(pol, pol_domain);
+       pol_for_each(p, pol, metadata) {
+               found_any = 1;
+               while (dom && strcmp(dom->dom, pol->value) < 0)
+                       dom = dom->next;
+               if (!dom || strcmp(dom->dom, pol->value) != 0)
+                       return 0;
+       }
+       return found_any;
+}
+
+struct domainlist *domain_from_array(struct mdinfo *mdi, const char *metadata)
+{
+       struct domainlist *domlist = NULL;
+
+       for (mdi = mdi->devs ; mdi ; mdi = mdi->next) {
+               struct dev_policy *pol = disk_policy(mdi);
+
+               domain_merge(&domlist, pol, metadata);
+               dev_policy_free(pol);
+       }
+       return domlist;
+}
+
+void domain_free(struct domainlist *dl)
+{
+       while (dl) {
+               struct domainlist *head = dl;
+               dl = dl->next;
+               free(head);
+       }
+}