These two functions do almost the same thing and duplicate some code. Merge their implementation into a single common function. res_counter_charge_locked() takes one more parameter but it doesn't seem to be used outside res_counter.c yet anyway. There is no (intended) change in the behaviour.
Showing the changes to kernel (1 of 3 files). Show all
Unified · Split
| @@ -22,75 +22,70 @@ void res_counter_init(struct res_counter *counter, struct res_counter *parent) · 21 unmodified lines | |||
| 22 | counter->parent = parent; | 22 | counter->parent = parent; |
| 23 | } | 23 | } |
| 24 | 24 | ||
| 25 | int res_counter_charge_locked(struct res_counter *counter, unsigned long val) | 25 | int res_counter_charge_locked(struct res_counter *counter, unsigned long val, |
| 26 | bool force) | ||
| 26 | { | 27 | { |
| 28 | int ret = 0; | ||
| 29 | |||
| 27 | if (counter->usage + val > counter->limit) { | 30 | if (counter->usage + val > counter->limit) { |
| 28 | counter->failcnt++; | 31 | counter->failcnt++; |
| 29 | return -ENOMEM; | 32 | ret = -ENOMEM; |
| 33 | if (!force) | ||
| 34 | return ret; | ||
| 30 | } | 35 | } |
| 31 | 36 | ||
| 32 | counter->usage += val; | 37 | counter->usage += val; |
| 33 | if (counter->usage > counter->max_usage) | 38 | if (!force && counter->usage > counter->max_usage) |
| 34 | counter->max_usage = counter->usage; | 39 | counter->max_usage = counter->usage; |
| 35 | return 0; | 40 | return ret; |
| 36 | } | 41 | } |
| 37 | 42 | ||
| 38 | int res_counter_charge(struct res_counter *counter, unsigned long val, | 43 | static int __res_counter_charge(struct res_counter *counter, unsigned long val, |
| 39 | struct res_counter **limit_fail_at) | 44 | struct res_counter **limit_fail_at, bool force) |
| 40 | { | 45 | { |
| 41 | int ret; | 46 | int ret, r; |
| 42 | unsigned long flags; | 47 | unsigned long flags; |
| 43 | struct res_counter *c, *u; | 48 | struct res_counter *c, *u; |
| 44 | 49 | ||
| 50 | r = ret = 0; | ||
| 45 | *limit_fail_at = NULL; | 51 | *limit_fail_at = NULL; |
| 46 | local_irq_save(flags); | 52 | local_irq_save(flags); |
| 47 | for (c = counter; c != NULL; c = c->parent) { | 53 | for (c = counter; c != NULL; c = c->parent) { |
| 48 | spin_lock(&c->lock); | 54 | spin_lock(&c->lock); |
| 49 | ret = res_counter_charge_locked(c, val); | 55 | r = res_counter_charge_locked(c, val, force); |
| 50 | spin_unlock(&c->lock); | 56 | spin_unlock(&c->lock); |
| 51 | if (ret < 0) { | 57 | if (r < 0 && !ret) { |
| 58 | ret = r; | ||
| 52 | *limit_fail_at = c; | 59 | *limit_fail_at = c; |
| 53 | goto undo; | 60 | if (!force) |
| 61 | break; | ||
| 54 | } | 62 | } |
| 55 | } | 63 | } |
| 56 | ret = 0; | 64 | |
| 57 | goto done; | 65 | if (ret < 0 && !force) { |
| 58 | undo: | 66 | for (u = counter; u != c; u = u->parent) { |
| 59 | for (u = counter; u != c; u = u->parent) { | 67 | spin_lock(&u->lock); |
| 60 | spin_lock(&u->lock); | 68 | res_counter_uncharge_locked(u, val); |
| 61 | res_counter_uncharge_locked(u, val); | 69 | spin_unlock(&u->lock); |
| 62 | spin_unlock(&u->lock); | 70 | } |
| 63 | } | 71 | } |
| 64 | done: | ||
| 65 | local_irq_restore(flags); | 72 | local_irq_restore(flags); |
| 73 | |||
| 66 | return ret; | 74 | return ret; |
| 67 | } | 75 | } |
| 68 | 76 | ||
| 77 | int res_counter_charge(struct res_counter *counter, unsigned long val, | ||
| 78 | struct res_counter **limit_fail_at) | ||
| 79 | { | ||
| 80 | return __res_counter_charge(counter, val, limit_fail_at, false); | ||
| 81 | } | ||
| 82 | |||
| 69 | int res_counter_charge_nofail(struct res_counter *counter, unsigned long val, | 83 | int res_counter_charge_nofail(struct res_counter *counter, unsigned long val, |
| 70 | struct res_counter **limit_fail_at) | 84 | struct res_counter **limit_fail_at) |
| 71 | { | 85 | { |
| 72 | int ret, r; | 86 | return __res_counter_charge(counter, val, limit_fail_at, true); |
| 73 | unsigned long flags; | ||
| 74 | struct res_counter *c; | ||
| 75 | |||
| 76 | r = ret = 0; | ||
| 77 | *limit_fail_at = NULL; | ||
| 78 | local_irq_save(flags); | ||
| 79 | for (c = counter; c != NULL; c = c->parent) { | ||
| 80 | spin_lock(&c->lock); | ||
| 81 | r = res_counter_charge_locked(c, val); | ||
| 82 | if (r) | ||
| 83 | c->usage += val; | ||
| 84 | spin_unlock(&c->lock); | ||
| 85 | if (r < 0 && ret == 0) { | ||
| 86 | *limit_fail_at = c; | ||
| 87 | ret = r; | ||
| 88 | } | ||
| 89 | } | ||
| 90 | local_irq_restore(flags); | ||
| 91 | |||
| 92 | return ret; | ||
| 93 | } | 87 | } |
| 88 | |||
| 94 | void res_counter_uncharge_locked(struct res_counter *counter, unsigned long val) | 89 | void res_counter_uncharge_locked(struct res_counter *counter, unsigned long val) |
| 95 | { | 90 | { |
| 96 | if (WARN_ON(counter->usage < val)) | 91 | if (WARN_ON(counter->usage < val)) |