1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 /*
30 *
31 * stats_create.c
32 *
33 * Routines for the `clean interface' to cachefs statistics.
34 */
35
36 #include <stdarg.h>
37 #include <libintl.h>
38 #include <sys/types.h>
39 #include <sys/stat.h>
40 #include <assert.h>
41 #include <sys/fs/cachefs_fs.h>
42 #include <string.h>
43 #include "stats.h"
44
45 void *malloc(), *calloc();
46
47 /* forward declarations of statics */
48 static stats_cookie_t *stats_create(char *);
49
50 static stats_cookie_t *
51 stats_create(char *progname)
52 {
53 stats_cookie_t *rc;
54
55 if ((rc = (stats_cookie_t *)calloc(1, sizeof (*rc))) == NULL)
56 goto out;
57
58 rc->st_magic = STATS_MAGIC;
59 if (rc->st_progname = strrchr(progname, '/'))
60 rc->st_progname++;
61 else
62 rc->st_progname = progname;
63
64 if ((rc->st_kstat_cookie = kstat_open()) == NULL) {
65 stats_perror(rc, SE_KERNEL,
66 gettext("Cannot initialize kstats"));
67 goto out;
68 }
69
70 out:
71 return (rc);
72 }
73
74 stats_cookie_t *
75 stats_create_unbound(char *progname)
76 {
77 stats_cookie_t *st;
78
79 if ((st = stats_create(progname)) == NULL)
80 goto out;
81
82 st->st_flags |= ST_VALID;
83
84 out:
85 return (st);
86 }
87
88 stats_cookie_t *
89 stats_create_mountpath(char *mountpath, char *progname)
90 {
91 stats_cookie_t *st;
92 kstat_t *key;
93 cachefs_kstat_key_t *k;
94 dev_t dev;
95 ino64_t ino;
96 struct stat64 s;
97 int i, n;
98
99 if ((st = stats_create(progname)) == NULL)
100 goto out;
101
102 if ((key = kstat_lookup(st->st_kstat_cookie, "cachefs", 0, "key"))
103 == NULL) {
104 stats_perror(st, SE_KERNEL,
105 gettext("Cannot lookup cachefs key kstat"));
106 goto out;
107 }
108 if (kstat_read(st->st_kstat_cookie, key, NULL) < 0) {
109 stats_perror(st, SE_KERNEL,
110 gettext("Cannot read cachefs key kstat"));
111 goto out;
112 }
113 k = (cachefs_kstat_key_t *)key->ks_data;
114 n = key->ks_ndata;
115
116 if (stat64(mountpath, &s) != 0) {
117 stats_perror(st, SE_FILE,
118 gettext("Cannot stat %s"), mountpath);
119 goto out;
120 }
121 ino = s.st_ino;
122 dev = s.st_dev;
123
124 for (i = 0; i < n; i++) {
125 k[i].ks_mountpoint += (uintptr_t)k;
126 k[i].ks_backfs += (uintptr_t)k;
127 k[i].ks_cachedir += (uintptr_t)k;
128 k[i].ks_cacheid += (uintptr_t)k;
129
130 if (! k[i].ks_mounted)
131 continue;
132
133 if ((stat64((char *)(uintptr_t)k[i].ks_mountpoint, &s) == 0) &&
134 (s.st_dev == dev) &&
135 (s.st_ino == ino))
136 break;
137 }
138
139 if (i >= n) {
140 stats_perror(st, SE_FILE,
141 gettext("%s: not a cachefs mountpoint"), mountpath);
142 goto out;
143 }
144
145 st->st_fsid = k[i].ks_id;
146
147 st->st_flags |= ST_VALID | ST_BOUND;
148
149 out:
150 return (st);
151 }
152
153 /*
154 * stats_next - bind the cookie to the next valid cachefs mount.
155 *
156 * returns cachefs_kstat_key_t *, which gives all the info you need.
157 * returns NULL if we're out of mounts, or if an error occured.
158 * returns malloc()ed data, which the client has to free() itself.
159 */
160
161 cachefs_kstat_key_t *
162 stats_next(stats_cookie_t *st)
163 {
164 kstat_t *key;
165 cachefs_kstat_key_t *k, *prc = NULL, *rc = NULL;
166 int i, n;
167
168 assert(stats_good(st));
169
170 if (((key = kstat_lookup(st->st_kstat_cookie, "cachefs", 0,
171 "key")) == NULL) ||
172 (kstat_read(st->st_kstat_cookie, key, NULL) < 0)) {
173 stats_perror(st, SE_KERNEL,
174 gettext("Cannot get cachefs key kstat"));
175 goto out;
176 }
177 k = (cachefs_kstat_key_t *)key->ks_data;
178 n = key->ks_ndata;
179
180 if (st->st_flags & ST_BOUND) {
181 for (i = 0; i < n; i++)
182 if (st->st_fsid == k[i].ks_id)
183 break;
184 ++i;
185 if (i < n) {
186 prc = k + i;
187 st->st_fsid = k[i].ks_id;
188 } else
189 st->st_flags &= ~ST_BOUND;
190 } else if (n > 0) {
191 st->st_fsid = k[0].ks_id;
192 st->st_flags |= ST_BOUND;
193 prc = k;
194 }
195
196 out:
197 if (prc != NULL) {
198 char *s;
199 int size;
200
201 prc->ks_mountpoint += (uintptr_t)k;
202 prc->ks_backfs += (uintptr_t)k;
203 prc->ks_cachedir += (uintptr_t)k;
204 prc->ks_cacheid += (uintptr_t)k;
205
206 size = sizeof (*rc);
207 size += strlen((char *)(uintptr_t)prc->ks_mountpoint) + 1;
208 size += strlen((char *)(uintptr_t)prc->ks_backfs) + 1;
209 size += strlen((char *)(uintptr_t)prc->ks_cachedir) + 1;
210 size += strlen((char *)(uintptr_t)prc->ks_cacheid) + 1;
211
212 if ((rc = (cachefs_kstat_key_t *)
213 malloc(size)) == NULL) {
214 stats_perror(st, SE_NOMEM,
215 gettext("Cannot malloc return code"));
216 } else {
217 memcpy(rc, prc, sizeof (*rc));
218 s = (char *)((uintptr_t)rc + sizeof (*rc));
219
220 (void) strcpy(s, (char *)(uintptr_t)prc->ks_mountpoint);
221 rc->ks_mountpoint = (uintptr_t)s;
222 s += strlen(s) + 1;
223 (void) strcpy(s, (char *)(uintptr_t)prc->ks_backfs);
224 rc->ks_backfs = (uintptr_t)s;
225 s += strlen(s) + 1;
226 (void) strcpy(s, (char *)(uintptr_t)prc->ks_cachedir);
227 rc->ks_cachedir = (uintptr_t)s;
228 s += strlen(s) + 1;
229 (void) strcpy(s, (char *)(uintptr_t)prc->ks_cacheid);
230 rc->ks_cacheid = (uintptr_t)s;
231 }
232 }
233
234 return (rc);
235 }
236
237 cachefs_kstat_key_t *
238 stats_getkey(stats_cookie_t *st)
239 {
240 kstat_t *ksp;
241 cachefs_kstat_key_t *k, *key, *rc = NULL;
242 int size;
243 char *s;
244
245 assert(stats_good(st));
246 assert(st->st_flags & ST_BOUND);
247
248 if (((ksp = kstat_lookup(st->st_kstat_cookie, "cachefs", 0,
249 "key")) == NULL) ||
250 (kstat_read(st->st_kstat_cookie, ksp, NULL) < 0)) {
251 stats_perror(st, SE_KERNEL,
252 gettext("Cannot get cachefs key kstat"));
253 goto out;
254 }
255 key = (cachefs_kstat_key_t *)ksp->ks_data;
256 k = key + st->st_fsid - 1;
257 k->ks_mountpoint += (uintptr_t)key;
258 k->ks_backfs += (uintptr_t)key;
259 k->ks_cachedir += (uintptr_t)key;
260 k->ks_cacheid += (uintptr_t)key;
261 size = sizeof (*rc);
262 size += strlen((char *)(uintptr_t)k->ks_mountpoint) + 1;
263 size += strlen((char *)(uintptr_t)k->ks_backfs) + 1;
264 size += strlen((char *)(uintptr_t)k->ks_cachedir) + 1;
265 size += strlen((char *)(uintptr_t)k->ks_cacheid) + 1;
266
267 if ((rc = (cachefs_kstat_key_t *)malloc(size)) == NULL)
268 stats_perror(st, SE_NOMEM,
269 gettext("Cannot malloc return code"));
270 else {
271 memcpy(rc, k, sizeof (*rc));
272 s = (char *)((uintptr_t)rc + sizeof (*rc));
273
274 (void) strcpy(s, (char *)(uintptr_t)k->ks_mountpoint);
275 rc->ks_mountpoint = (uintptr_t)s;
276 s += strlen(s) + 1;
277 (void) strcpy(s, (char *)(uintptr_t)k->ks_backfs);
278 rc->ks_backfs = (uintptr_t)s;
279 s += strlen(s) + 1;
280 (void) strcpy(s, (char *)(uintptr_t)k->ks_cachedir);
281 rc->ks_cachedir = (uintptr_t)s;
282 s += strlen(s) + 1;
283 (void) strcpy(s, (char *)(uintptr_t)k->ks_cacheid);
284 rc->ks_cacheid = (uintptr_t)s;
285 s += strlen(s) + 1;
286 }
287
288 assert(rc->ks_id == st->st_fsid);
289
290 out:
291 return (rc);
292 }
293
294 void
295 stats_destroy(stats_cookie_t *st)
296 {
297 void free();
298
299 if (st == NULL)
300 return;
301
302 if (st->st_kstat_cookie != NULL)
303 kstat_close(st->st_kstat_cookie);
304 if (st->st_logxdr.x_ops != NULL)
305 xdr_destroy(&st->st_logxdr);
306 if ((st->st_logstream != NULL) && (st->st_flags & ST_LFOPEN))
307 (void) fclose(st->st_logstream);
308
309 /*
310 * we don't want to depend on dbm (or stats_dbm), so we don't
311 * do a stats_dbm_close. we do try to require the client to
312 * have done it, via an assert(), however.
313 */
314
315 assert(! (st->st_flags & ST_DBMOPEN));
316
317 st->st_magic++;
318
319 free(st);
320 }
321
322 int
323 stats_good(stats_cookie_t *st)
324 {
325 if (st == NULL)
326 return (0);
327 if (st->st_magic != STATS_MAGIC)
328 return (0);
329 if (! (st->st_flags & ST_VALID))
330 return (0);
331
332 return (1);
333 }
334
335 void
336 /*PRINTFLIKE3*/
337 stats_perror(stats_cookie_t *st, int Errno, char *fmt, ...)
338 {
339
340 va_list ap;
341
342 assert(st != NULL);
343 assert(st->st_magic == STATS_MAGIC);
344
345 va_start(ap, fmt);
346 (void) vsnprintf(st->st_errorstr, sizeof (st->st_errorstr), fmt, ap);
347 va_end(ap);
348
349 st->st_errno = Errno;
350
351 st->st_flags |= ST_ERROR;
352 }
353
354 char *
355 stats_errorstr(stats_cookie_t *st)
356 {
357 assert(st != NULL);
358 assert(st->st_magic == STATS_MAGIC);
359
360 return (st->st_errorstr);
361 }
362
363 int
364 stats_errno(stats_cookie_t *st)
365 {
366 assert(st != NULL);
367 assert(st->st_magic == STATS_MAGIC);
368
369 return (st->st_errno);
370 }
371
372 int
373 stats_inerror(stats_cookie_t *st)
374 {
375 assert(st != NULL);
376 assert(st->st_magic == STATS_MAGIC);
377
378 return (st->st_flags & ST_ERROR);
379 }