| @@ -22,75 +22,70 @@ void res_counter_init(struct res_counter *counter, struct res_counter *parent) · 21 unmodified lines |
| 22 | 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 | 30 | if (counter->usage + val > counter->limit) { |
| 28 | 31 | counter->failcnt++; |
| 29 | | − return -ENOMEM; |
| 32 | + ret = -ENOMEM; |
| 33 | + if (!force) |
| 34 | + return ret; |
| 30 | 35 | } |
| 31 | 36 | |
| 32 | 37 | counter->usage += val; |
| 33 | | − if (counter->usage > counter->max_usage) |
| 38 | + if (!force && counter->usage > counter->max_usage) |
| 34 | 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, |
| 39 | | − struct res_counter **limit_fail_at) |
| 43 | +static int __res_counter_charge(struct res_counter *counter, unsigned long val, |
| 44 | + struct res_counter **limit_fail_at, bool force) |
| 40 | 45 | { |
| 41 | | − int ret; |
| 46 | + int ret, r; |
| 42 | 47 | unsigned long flags; |
| 43 | 48 | struct res_counter *c, *u; |
| 44 | 49 | |
| 50 | + r = ret = 0; |
| 45 | 51 | *limit_fail_at = NULL; |
| 46 | 52 | local_irq_save(flags); |
| 47 | 53 | for (c = counter; c != NULL; c = c->parent) { |
| 48 | 54 | spin_lock(&c->lock); |
| 49 | | − ret = res_counter_charge_locked(c, val); |
| 55 | + r = res_counter_charge_locked(c, val, force); |
| 50 | 56 | spin_unlock(&c->lock); |
| 51 | | − if (ret < 0) { |
| 57 | + if (r < 0 && !ret) { |
| 58 | + ret = r; |
| 52 | 59 | *limit_fail_at = c; |
| 53 | | − goto undo; |
| 60 | + if (!force) |
| 61 | + break; |
| 54 | 62 | } |
| 55 | 63 | } |
| 56 | | − ret = 0; |
| 57 | | − goto done; |
| 58 | | −undo: |
| 59 | | − for (u = counter; u != c; u = u->parent) { |
| 60 | | − spin_lock(&u->lock); |
| 61 | | − res_counter_uncharge_locked(u, val); |
| 62 | | − spin_unlock(&u->lock); |
| 64 | + |
| 65 | + if (ret < 0 && !force) { |
| 66 | + for (u = counter; u != c; u = u->parent) { |
| 67 | + spin_lock(&u->lock); |
| 68 | + res_counter_uncharge_locked(u, val); |
| 69 | + spin_unlock(&u->lock); |
| 70 | + } |
| 63 | 71 | } |
| 64 | | −done: |
| 65 | 72 | local_irq_restore(flags); |
| 73 | + |
| 66 | 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 | 83 | int res_counter_charge_nofail(struct res_counter *counter, unsigned long val, |
| 70 | 84 | struct res_counter **limit_fail_at) |
| 71 | 85 | { |
| 72 | | − int ret, r; |
| 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; |
| 86 | + return __res_counter_charge(counter, val, limit_fail_at, true); |
| 93 | 87 | } |
| 88 | + |
| 94 | 89 | void res_counter_uncharge_locked(struct res_counter *counter, unsigned long val) |
| 95 | 90 | { |
| 96 | 91 | if (WARN_ON(counter->usage < val)) |