kernel/range.c

   1 /*
   2  * Range add and subtract
   3  */
   4 #include <linux/kernel.h>
   5 #include <linux/init.h>
   6 #include <linux/sort.h>
   7
   8 #include <linux/range.h>
   9
  10 int add_range(struct range *range, int az, int nr_range, u64 start, u64 end)
  11 {
  12         if (start >= end)
  13                 return nr_range;
  14
  15         /* Out of slots: */
  16         if (nr_range >= az)
  17                 return nr_range;
  18
  19         range[nr_range].start = start;
  20         range[nr_range].end = end;
  21
  22         nr_range++;
  23
  24         return nr_range;
  25 }
  26
  27 int add_range_with_merge(struct range *range, int az, int nr_range,
  28                      u64 start, u64 end)
  29 {
  30         int i;
  31
  32         if (start >= end)
  33                 return nr_range;
  34
  35         /* Try to merge it with old one: */
  36         for (i = 0; i < nr_range; i++) {
  37                 u64 final_start, final_end;
  38                 u64 common_start, common_end;
  39
  40                 if (!range[i].end)
  41                         continue;
  42
  43                 common_start = max(range[i].start, start);
  44                 common_end = min(range[i].end, end);
  45                 if (common_start > common_end)
  46                         continue;
  47
  48                 final_start = min(range[i].start, start);
  49                 final_end = max(range[i].end, end);
  50
  51                 range[i].start = final_start;
  52                 range[i].end =  final_end;
  53                 return nr_range;
  54         }
  55
  56         /* Need to add it: */
  57         return add_range(range, az, nr_range, start, end);
  58 }
  59
  60 void subtract_range(struct range *range, int az, u64 start, u64 end)
  61 {
  62         int i, j;
  63
  64         if (start >= end)
  65                 return;
  66
  67         for (j = 0; j < az; j++) {
  68                 if (!range[j].end)
  69                         continue;
  70
  71                 if (start <= range[j].start && end >= range[j].end) {
  72                         range[j].start = 0;
  73                         range[j].end = 0;
  74                         continue;
  75                 }
  76
  77                 if (start <= range[j].start && end < range[j].end &&
  78                     range[j].start < end) {
  79                         range[j].start = end;
  80                         continue;
  81                 }
  82
  83
  84                 if (start > range[j].start && end >= range[j].end &&
  85                     range[j].end > start) {
  86                         range[j].end = start;
  87                         continue;
  88                 }
  89
  90                 if (start > range[j].start && end < range[j].end) {
  91                         /* Find the new spare: */
  92                         for (i = 0; i < az; i++) {
  93                                 if (range[i].end == 0)
  94                                         break;
  95                         }
  96                         if (i < az) {
  97                                 range[i].end = range[j].end;
  98                                 range[i].start = end;
  99                         } else {
 100                                 pr_err("%s: run out of slot in ranges\n",
 101                                         __func__);
 102                         }
 103                         range[j].end = start;
 104                         continue;
 105                 }
 106         }
 107 }
 108
 109 static int cmp_range(const void *x1, const void *x2)
 110 {
 111         const struct range *r1 = x1;
 112         const struct range *r2 = x2;
 113         s64 start1, start2;
 114
 115         start1 = r1->start;
 116         start2 = r2->start;
 117
 118         return start1 - start2;
 119 }
 120
 121 int clean_sort_range(struct range *range, int az)
 122 {
 123         int i, j, k = az - 1, nr_range = az;
 124
 125         for (i = 0; i < k; i++) {
 126                 if (range[i].end)
 127                         continue;
 128                 for (j = k; j > i; j--) {
 129                         if (range[j].end) {
 130                                 k = j;
 131                                 break;
 132                         }
 133                 }
 134                 if (j == i)
 135                         break;
 136                 range[i].start = range[k].start;
 137                 range[i].end   = range[k].end;
 138                 range[k].start = 0;
 139                 range[k].end   = 0;
 140                 k--;
 141         }
 142         /* count it */
 143         for (i = 0; i < az; i++) {
 144                 if (!range[i].end) {
 145                         nr_range = i;
 146                         break;
 147                 }
 148         }
 149
 150         /* sort them */
 151         sort(range, nr_range, sizeof(struct range), cmp_range, NULL);
 152
 153         return nr_range;
 154 }
 155
 156 void sort_range(struct range *range, int nr_range)
 157 {
 158         /* sort them */
 159         sort(range, nr_range, sizeof(struct range), cmp_range, NULL);
 160 }