source: mainline/uspace/lib/c/generic/cap.c@ 1433ecda

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 1433ecda was 1433ecda, checked in by Jiri Svoboda <jiri@…>, 7 years ago

Fix cstyle: make ccheck-fix and commit only files where all the changes are good.
  • Property mode set to 100644
File size: 6.2 KB
Line 
1/*
2 * Copyright (c) 2015 Jiri Svoboda
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup libc
30 * @{
31 */
32/**
33 * @file Storage capacity specification.
34 */
35
36#include <cap.h>
37#include <errno.h>
38#include <imath.h>
39#include <stdio.h>
40#include <str.h>
41
42/** Simplified capacity parameters */
43enum {
44 /** Simplified capacity maximum integer digits */
45 scap_max_idig = 3,
46 /** Simplified capacity maximum significant digits */
47 scap_max_sdig = 4
48};
49
50static const char *cu_str[] = {
51 [cu_byte] = "B",
52 [cu_kbyte] = "kB",
53 [cu_mbyte] = "MB",
54 [cu_gbyte] = "GB",
55 [cu_tbyte] = "TB",
56 [cu_pbyte] = "PB",
57 [cu_ebyte] = "EB",
58 [cu_zbyte] = "ZB",
59 [cu_ybyte] = "YB"
60};
61
62void cap_from_blocks(uint64_t nblocks, size_t block_size, cap_spec_t *cap)
63{
64 uint64_t tsize;
65
66 tsize = nblocks * block_size;
67 cap->m = tsize;
68 cap->dp = 0;
69 cap->cunit = cu_byte;
70}
71
72/** Convert capacity to blocks.
73 *
74 * If the value of bytes is not integer, it is properly rounded. If the number
75 * of bytes is not divisible by the number of blocks, it is rounded
76 * up to an integer number of blocks.
77 *
78 * A capacity value entails precision, i.e. it corresponds to a range
79 * of values. @a cvsel selects the value to return. @c cv_nom gives
80 * the nominal (middle) value, @c cv_min gives the minimum value
81 * and @c cv_max gives the maximum value.
82 */
83errno_t cap_to_blocks(cap_spec_t *cap, cap_vsel_t cvsel, size_t block_size,
84 uint64_t *rblocks)
85{
86 int exp;
87 uint64_t bytes;
88 uint64_t f;
89 uint64_t adj;
90 uint64_t blocks;
91 uint64_t rem;
92 errno_t rc;
93
94 exp = cap->cunit * 3 - cap->dp;
95 if (exp < 0) {
96 rc = ipow10_u64(-exp, &f);
97 if (rc != EOK)
98 return ERANGE;
99 bytes = (cap->m + (f / 2)) / f;
100 if (bytes * f - (f / 2) != cap->m)
101 return ERANGE;
102 } else {
103 rc = ipow10_u64(exp, &f);
104 if (rc != EOK)
105 return ERANGE;
106
107 adj = 0;
108 switch (cvsel) {
109 case cv_nom:
110 adj = 0;
111 break;
112 case cv_min:
113 adj = -(f / 2);
114 break;
115 case cv_max:
116 adj = f / 2 - 1;
117 break;
118 }
119
120 bytes = cap->m * f + adj;
121 if ((bytes - adj) / f != cap->m)
122 return ERANGE;
123 }
124
125 rem = bytes % block_size;
126 if ((bytes + rem) < bytes)
127 return ERANGE;
128
129 blocks = (bytes + rem) / block_size;
130
131 *rblocks = blocks;
132 return EOK;
133}
134
135/** Simplify and round capacity to a human-friendly form.
136 *
137 * Change unit and round the number so that we have at most three integer
138 * digits and at most two fractional digits, e.g abc.xy <unit>.
139 */
140void cap_simplify(cap_spec_t *cap)
141{
142 uint64_t div;
143 uint64_t maxv;
144 unsigned sdig;
145 unsigned rdig;
146 errno_t rc;
147
148 /* Change units so that we have at most @c scap_max_idig integer digits */
149 rc = ipow10_u64(scap_max_idig, &maxv);
150 assert(rc == EOK);
151
152 rc = ipow10_u64(cap->dp, &div);
153 assert(rc == EOK);
154
155 while (cap->m / div >= maxv) {
156 ++cap->cunit;
157 cap->dp += 3;
158 div = div * 1000;
159 }
160
161 /* Round the number so that we have at most @c scap_max_sdig significant digits */
162 sdig = 1 + ilog10_u64(cap->m); /* number of significant digits */
163 if (sdig > scap_max_sdig) {
164 /* Number of digits to remove */
165 rdig = sdig - scap_max_sdig;
166 if (rdig > cap->dp)
167 rdig = cap->dp;
168
169 rc = ipow10_u64(rdig, &div);
170 assert(rc == EOK);
171
172 cap->m = (cap->m + (div / 2)) / div;
173 cap->dp -= rdig;
174 }
175}
176
177errno_t cap_format(cap_spec_t *cap, char **rstr)
178{
179 errno_t rc;
180 int ret;
181 const char *sunit;
182 uint64_t ipart;
183 uint64_t fpart;
184 uint64_t div;
185
186 sunit = NULL;
187
188 assert(cap->cunit < CU_LIMIT);
189
190 rc = ipow10_u64(cap->dp, &div);
191 if (rc != EOK)
192 return rc;
193
194 ipart = cap->m / div;
195 fpart = cap->m % div;
196
197 sunit = cu_str[cap->cunit];
198 if (cap->dp > 0) {
199 ret = asprintf(rstr, "%" PRIu64 ".%0*" PRIu64 " %s", ipart,
200 (int)cap->dp, fpart, sunit);
201 } else {
202 ret = asprintf(rstr, "%" PRIu64 " %s", ipart, sunit);
203 }
204 if (ret < 0)
205 return ENOMEM;
206
207 return EOK;
208}
209
210static errno_t cap_digit_val(char c, int *val)
211{
212 switch (c) {
213 case '0':
214 *val = 0;
215 break;
216 case '1':
217 *val = 1;
218 break;
219 case '2':
220 *val = 2;
221 break;
222 case '3':
223 *val = 3;
224 break;
225 case '4':
226 *val = 4;
227 break;
228 case '5':
229 *val = 5;
230 break;
231 case '6':
232 *val = 6;
233 break;
234 case '7':
235 *val = 7;
236 break;
237 case '8':
238 *val = 8;
239 break;
240 case '9':
241 *val = 9;
242 break;
243 default:
244 return EINVAL;
245 }
246
247 return EOK;
248}
249
250errno_t cap_parse(const char *str, cap_spec_t *cap)
251{
252 const char *eptr;
253 const char *p;
254 int d;
255 int dp;
256 unsigned long m;
257 int i;
258
259 m = 0;
260
261 eptr = str;
262 while (cap_digit_val(*eptr, &d) == EOK) {
263 m = m * 10 + d;
264 ++eptr;
265 }
266
267 if (*eptr == '.') {
268 ++eptr;
269 dp = 0;
270 while (cap_digit_val(*eptr, &d) == EOK) {
271 m = m * 10 + d;
272 ++dp;
273 ++eptr;
274 }
275 } else {
276 dp = 0;
277 }
278
279 while (*eptr == ' ')
280 ++eptr;
281
282 if (*eptr == '\0') {
283 cap->cunit = cu_byte;
284 } else {
285 for (i = 0; i < CU_LIMIT; i++) {
286 if (str_lcasecmp(eptr, cu_str[i],
287 str_length(cu_str[i])) == 0) {
288 p = eptr + str_size(cu_str[i]);
289 while (*p == ' ')
290 ++p;
291 if (*p == '\0')
292 goto found;
293 }
294 }
295
296 return EINVAL;
297 found:
298 cap->cunit = i;
299 }
300
301 cap->m = m;
302 cap->dp = dp;
303 return EOK;
304}
305
306/** @}
307 */
Note: See TracBrowser for help on using the repository browser.