~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/res_counter.h

Version: ~ [ linux-5.17-rc1 ] ~ [ linux-5.16.2 ] ~ [ linux-5.15.16 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.93 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.173 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.225 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.262 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.297 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.299 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 #ifndef __RES_COUNTER_H__
  2 #define __RES_COUNTER_H__
  3 
  4 /*
  5  * Resource Counters
  6  * Contain common data types and routines for resource accounting
  7  *
  8  * Copyright 2007 OpenVZ SWsoft Inc
  9  *
 10  * Author: Pavel Emelianov <xemul@openvz.org>
 11  *
 12  * See Documentation/cgroups/resource_counter.txt for more
 13  * info about what this counter is.
 14  */
 15 
 16 #include <linux/spinlock.h>
 17 #include <linux/errno.h>
 18 
 19 /*
 20  * The core object. the cgroup that wishes to account for some
 21  * resource may include this counter into its structures and use
 22  * the helpers described beyond
 23  */
 24 
 25 struct res_counter {
 26         /*
 27          * the current resource consumption level
 28          */
 29         unsigned long long usage;
 30         /*
 31          * the maximal value of the usage from the counter creation
 32          */
 33         unsigned long long max_usage;
 34         /*
 35          * the limit that usage cannot exceed
 36          */
 37         unsigned long long limit;
 38         /*
 39          * the limit that usage can be exceed
 40          */
 41         unsigned long long soft_limit;
 42         /*
 43          * the number of unsuccessful attempts to consume the resource
 44          */
 45         unsigned long long failcnt;
 46         /*
 47          * the lock to protect all of the above.
 48          * the routines below consider this to be IRQ-safe
 49          */
 50         spinlock_t lock;
 51         /*
 52          * Parent counter, used for hierarchial resource accounting
 53          */
 54         struct res_counter *parent;
 55 };
 56 
 57 #define RESOURCE_MAX (unsigned long long)LLONG_MAX
 58 
 59 /**
 60  * Helpers to interact with userspace
 61  * res_counter_read_u64() - returns the value of the specified member.
 62  * res_counter_read/_write - put/get the specified fields from the
 63  * res_counter struct to/from the user
 64  *
 65  * @counter:     the counter in question
 66  * @member:  the field to work with (see RES_xxx below)
 67  * @buf:     the buffer to opeate on,...
 68  * @nbytes:  its size...
 69  * @pos:     and the offset.
 70  */
 71 
 72 u64 res_counter_read_u64(struct res_counter *counter, int member);
 73 
 74 ssize_t res_counter_read(struct res_counter *counter, int member,
 75                 const char __user *buf, size_t nbytes, loff_t *pos,
 76                 int (*read_strategy)(unsigned long long val, char *s));
 77 
 78 int res_counter_memparse_write_strategy(const char *buf,
 79                                         unsigned long long *res);
 80 
 81 /*
 82  * the field descriptors. one for each member of res_counter
 83  */
 84 
 85 enum {
 86         RES_USAGE,
 87         RES_MAX_USAGE,
 88         RES_LIMIT,
 89         RES_FAILCNT,
 90         RES_SOFT_LIMIT,
 91 };
 92 
 93 /*
 94  * helpers for accounting
 95  */
 96 
 97 void res_counter_init(struct res_counter *counter, struct res_counter *parent);
 98 
 99 /*
100  * charge - try to consume more resource.
101  *
102  * @counter: the counter
103  * @val: the amount of the resource. each controller defines its own
104  *       units, e.g. numbers, bytes, Kbytes, etc
105  *
106  * returns 0 on success and <0 if the counter->usage will exceed the
107  * counter->limit _locked call expects the counter->lock to be taken
108  *
109  * charge_nofail works the same, except that it charges the resource
110  * counter unconditionally, and returns < 0 if the after the current
111  * charge we are over limit.
112  */
113 
114 int __must_check res_counter_charge_locked(struct res_counter *counter,
115                                            unsigned long val, bool force);
116 int __must_check res_counter_charge(struct res_counter *counter,
117                 unsigned long val, struct res_counter **limit_fail_at);
118 int res_counter_charge_nofail(struct res_counter *counter,
119                 unsigned long val, struct res_counter **limit_fail_at);
120 
121 /*
122  * uncharge - tell that some portion of the resource is released
123  *
124  * @counter: the counter
125  * @val: the amount of the resource
126  *
127  * these calls check for usage underflow and show a warning on the console
128  * _locked call expects the counter->lock to be taken
129  *
130  * returns the total charges still present in @counter.
131  */
132 
133 u64 res_counter_uncharge_locked(struct res_counter *counter, unsigned long val);
134 u64 res_counter_uncharge(struct res_counter *counter, unsigned long val);
135 
136 u64 res_counter_uncharge_until(struct res_counter *counter,
137                                struct res_counter *top,
138                                unsigned long val);
139 /**
140  * res_counter_margin - calculate chargeable space of a counter
141  * @cnt: the counter
142  *
143  * Returns the difference between the hard limit and the current usage
144  * of resource counter @cnt.
145  */
146 static inline unsigned long long res_counter_margin(struct res_counter *cnt)
147 {
148         unsigned long long margin;
149         unsigned long flags;
150 
151         spin_lock_irqsave(&cnt->lock, flags);
152         if (cnt->limit > cnt->usage)
153                 margin = cnt->limit - cnt->usage;
154         else
155                 margin = 0;
156         spin_unlock_irqrestore(&cnt->lock, flags);
157         return margin;
158 }
159 
160 /**
161  * Get the difference between the usage and the soft limit
162  * @cnt: The counter
163  *
164  * Returns 0 if usage is less than or equal to soft limit
165  * The difference between usage and soft limit, otherwise.
166  */
167 static inline unsigned long long
168 res_counter_soft_limit_excess(struct res_counter *cnt)
169 {
170         unsigned long long excess;
171         unsigned long flags;
172 
173         spin_lock_irqsave(&cnt->lock, flags);
174         if (cnt->usage <= cnt->soft_limit)
175                 excess = 0;
176         else
177                 excess = cnt->usage - cnt->soft_limit;
178         spin_unlock_irqrestore(&cnt->lock, flags);
179         return excess;
180 }
181 
182 static inline void res_counter_reset_max(struct res_counter *cnt)
183 {
184         unsigned long flags;
185 
186         spin_lock_irqsave(&cnt->lock, flags);
187         cnt->max_usage = cnt->usage;
188         spin_unlock_irqrestore(&cnt->lock, flags);
189 }
190 
191 static inline void res_counter_reset_failcnt(struct res_counter *cnt)
192 {
193         unsigned long flags;
194 
195         spin_lock_irqsave(&cnt->lock, flags);
196         cnt->failcnt = 0;
197         spin_unlock_irqrestore(&cnt->lock, flags);
198 }
199 
200 static inline int res_counter_set_limit(struct res_counter *cnt,
201                 unsigned long long limit)
202 {
203         unsigned long flags;
204         int ret = -EBUSY;
205 
206         spin_lock_irqsave(&cnt->lock, flags);
207         if (cnt->usage <= limit) {
208                 cnt->limit = limit;
209                 ret = 0;
210         }
211         spin_unlock_irqrestore(&cnt->lock, flags);
212         return ret;
213 }
214 
215 static inline int
216 res_counter_set_soft_limit(struct res_counter *cnt,
217                                 unsigned long long soft_limit)
218 {
219         unsigned long flags;
220 
221         spin_lock_irqsave(&cnt->lock, flags);
222         cnt->soft_limit = soft_limit;
223         spin_unlock_irqrestore(&cnt->lock, flags);
224         return 0;
225 }
226 
227 #endif
228 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp