Print this page
11083 support NFS server in zone
Portions contributed by: Dan Kruchinin <dan.kruchinin@nexenta.com>
Portions contributed by: Stepan Zastupov <stepan.zastupov@gmail.com>
Portions contributed by: Joyce McIntosh <joyce.mcintosh@nexenta.com>
Portions contributed by: Mike Zeller <mike@mikezeller.net>
Portions contributed by: Dan McDonald <danmcd@joyent.com>
Portions contributed by: Gordon Ross <gordon.w.ross@gmail.com>
Portions contributed by: Vitaliy Gusev <gusev.vitaliy@gmail.com>
Reviewed by: Rick McNeal <rick.mcneal@nexenta.com>
Reviewed by: Rob Gittins <rob.gittins@nexenta.com>
Reviewed by: Sanjay Nadkarni <sanjay.nadkarni@nexenta.com>
Reviewed by: Jason King <jbk@joyent.com>
Reviewed by: C Fraire <cfraire@me.com>
Change-Id: I22f289d357503f9b48a0bc2482cc4328a6d43d16
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/fs/nfs/nfs_stats.c
+++ new/usr/src/uts/common/fs/nfs/nfs_stats.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 23 * Use is subject to license terms.
24 24 */
25 25
26 26 #include <sys/types.h>
27 27 #include <sys/kstat.h>
28 28 #include <sys/zone.h>
29 29 #include <sys/kmem.h>
30 30 #include <sys/systm.h>
31 31
32 32 #include <nfs/nfs.h>
33 33 #include <nfs/nfs4_kprot.h>
34 34
35 35 /*
36 36 * Key to retrieve per-zone data corresponding to NFS kstats consumed by
37 37 * nfsstat(1m).
|
↓ open down ↓ |
37 lines elided |
↑ open up ↑ |
38 38 */
39 39 zone_key_t nfsstat_zone_key;
40 40
41 41 /*
42 42 * Convenience routine to create a named kstat associated with zoneid, named
43 43 * module:0:name:"misc", using the provided template to initialize the names
44 44 * and values of the stats.
45 45 */
46 46 static kstat_named_t *
47 47 nfsstat_zone_init_common(zoneid_t zoneid, const char *module, int vers,
48 - const char *name, const kstat_named_t *template,
49 - size_t template_size)
48 + const char *name, const kstat_named_t *template,
49 + size_t template_size)
50 50 {
51 51 kstat_t *ksp;
52 52 kstat_named_t *ks_data;
53 53
54 54 ks_data = kmem_alloc(template_size, KM_SLEEP);
55 55 bcopy(template, ks_data, template_size);
56 56 if ((ksp = kstat_create_zone(module, vers, name, "misc",
57 57 KSTAT_TYPE_NAMED, template_size / sizeof (kstat_named_t),
58 58 KSTAT_FLAG_VIRTUAL | KSTAT_FLAG_WRITABLE, zoneid)) != NULL) {
59 59 ksp->ks_data = ks_data;
60 60 kstat_install(ksp);
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
61 61 }
62 62 return (ks_data);
63 63 }
64 64
65 65 /*
66 66 * Convenience routine to remove a kstat in specified zone with name
67 67 * module:0:name.
68 68 */
69 69 static void
70 70 nfsstat_zone_fini_common(zoneid_t zoneid, const char *module, int vers,
71 - const char *name)
71 + const char *name)
72 72 {
73 73 kstat_delete_byname_zone(module, vers, name, zoneid);
74 74 }
75 75
76 76 /*
77 77 * Server statistics. These are defined here, rather than in the server
78 78 * code, so that they can be referenced before the nfssrv kmod is loaded.
79 79 *
80 80 * The "calls" counter is a Contract Private interface covered by
81 81 * PSARC/2001/357. Please contact contract-2001-357-01@eng.sun.com before
82 82 * making any changes.
83 83 */
84 84
85 85 static const kstat_named_t svstat_tmpl[] = {
86 86 { "calls", KSTAT_DATA_UINT64 },
87 87 { "badcalls", KSTAT_DATA_UINT64 },
88 88 { "referrals", KSTAT_DATA_UINT64 },
89 89 { "referlinks", KSTAT_DATA_UINT64 },
90 90 };
91 91
92 -/* Points to the global zone server kstat data for all nfs versions */
93 -kstat_named_t *global_svstat_ptr[NFS_VERSMAX + 1];
94 -
95 92 static void
96 93 nfsstat_zone_init_server(zoneid_t zoneid, kstat_named_t *svstatp[])
97 94 {
98 95 int vers;
99 96
100 - /*
101 - * first two indexes of these arrays are not used, so initialize
102 - * to NULL
103 - */
104 - svstatp[0] = NULL;
105 - svstatp[1] = NULL;
106 - global_svstat_ptr[0] = NULL;
107 - global_svstat_ptr[0] = NULL;
108 -
109 97 for (vers = NFS_VERSION; vers <= NFS_V4; vers++) {
110 98 svstatp[vers] = nfsstat_zone_init_common(zoneid, "nfs", vers,
111 99 "nfs_server", svstat_tmpl, sizeof (svstat_tmpl));
112 - if (zoneid == GLOBAL_ZONEID)
113 - global_svstat_ptr[vers] = svstatp[vers];
114 100 }
115 101 }
116 102
117 103 static void
118 -nfsstat_zone_fini_server(zoneid_t zoneid, kstat_named_t **svstatp)
104 +nfsstat_zone_fini_server(zoneid_t zoneid, kstat_named_t *svstatp[])
119 105 {
120 106 int vers;
121 107 for (vers = NFS_VERSION; vers <= NFS_V4; vers++) {
122 - if (zoneid == GLOBAL_ZONEID)
123 - global_svstat_ptr[vers] = NULL;
124 108 nfsstat_zone_fini_common(zoneid, "nfs", vers, "nfs_server");
125 109 kmem_free(svstatp[vers], sizeof (svstat_tmpl));
126 110 }
127 111 }
128 112
129 113 /*
130 114 * NFSv2 client stats
131 115 */
132 116 static const kstat_named_t rfsreqcnt_v2_tmpl[] = {
133 117 { "null", KSTAT_DATA_UINT64 },
134 118 { "getattr", KSTAT_DATA_UINT64 },
135 119 { "setattr", KSTAT_DATA_UINT64 },
136 120 { "root", KSTAT_DATA_UINT64 },
137 121 { "lookup", KSTAT_DATA_UINT64 },
138 122 { "readlink", KSTAT_DATA_UINT64 },
139 123 { "read", KSTAT_DATA_UINT64 },
140 124 { "wrcache", KSTAT_DATA_UINT64 },
141 125 { "write", KSTAT_DATA_UINT64 },
142 126 { "create", KSTAT_DATA_UINT64 },
143 127 { "remove", KSTAT_DATA_UINT64 },
144 128 { "rename", KSTAT_DATA_UINT64 },
145 129 { "link", KSTAT_DATA_UINT64 },
146 130 { "symlink", KSTAT_DATA_UINT64 },
147 131 { "mkdir", KSTAT_DATA_UINT64 },
148 132 { "rmdir", KSTAT_DATA_UINT64 },
149 133 { "readdir", KSTAT_DATA_UINT64 },
150 134 { "statfs", KSTAT_DATA_UINT64 }
151 135 };
152 136
153 137 static void
154 138 nfsstat_zone_init_rfsreq_v2(zoneid_t zoneid, struct nfs_version_stats *statsp)
155 139 {
156 140 statsp->rfsreqcnt_ptr = nfsstat_zone_init_common(zoneid, "nfs", 0,
157 141 "rfsreqcnt_v2", rfsreqcnt_v2_tmpl, sizeof (rfsreqcnt_v2_tmpl));
158 142 }
159 143
160 144 static void
161 145 nfsstat_zone_fini_rfsreq_v2(zoneid_t zoneid, struct nfs_version_stats *statsp)
162 146 {
163 147 nfsstat_zone_fini_common(zoneid, "nfs", 0, "rfsreqcnt_v2");
164 148 kmem_free(statsp->rfsreqcnt_ptr, sizeof (rfsreqcnt_v2_tmpl));
165 149 }
166 150
167 151 /*
168 152 * NFSv2 server stats
169 153 */
170 154 static const kstat_named_t rfsproccnt_v2_tmpl[] = {
171 155 { "null", KSTAT_DATA_UINT64 },
172 156 { "getattr", KSTAT_DATA_UINT64 },
173 157 { "setattr", KSTAT_DATA_UINT64 },
174 158 { "root", KSTAT_DATA_UINT64 },
175 159 { "lookup", KSTAT_DATA_UINT64 },
176 160 { "readlink", KSTAT_DATA_UINT64 },
177 161 { "read", KSTAT_DATA_UINT64 },
178 162 { "wrcache", KSTAT_DATA_UINT64 },
179 163 { "write", KSTAT_DATA_UINT64 },
180 164 { "create", KSTAT_DATA_UINT64 },
|
↓ open down ↓ |
47 lines elided |
↑ open up ↑ |
181 165 { "remove", KSTAT_DATA_UINT64 },
182 166 { "rename", KSTAT_DATA_UINT64 },
183 167 { "link", KSTAT_DATA_UINT64 },
184 168 { "symlink", KSTAT_DATA_UINT64 },
185 169 { "mkdir", KSTAT_DATA_UINT64 },
186 170 { "rmdir", KSTAT_DATA_UINT64 },
187 171 { "readdir", KSTAT_DATA_UINT64 },
188 172 { "statfs", KSTAT_DATA_UINT64 }
189 173 };
190 174
191 -kstat_named_t *rfsproccnt_v2_ptr;
192 -
193 -static void
194 -nfsstat_zone_init_rfsproc_v2(zoneid_t zoneid, struct nfs_version_stats *statsp)
195 -{
196 - kstat_named_t *ks_data;
197 -
198 - ks_data = nfsstat_zone_init_common(zoneid, "nfs", 0, "rfsproccnt_v2",
199 - rfsproccnt_v2_tmpl, sizeof (rfsproccnt_v2_tmpl));
200 - statsp->rfsproccnt_ptr = ks_data;
201 - if (zoneid == GLOBAL_ZONEID)
202 - rfsproccnt_v2_ptr = ks_data;
203 -}
204 -
205 -static void
206 -nfsstat_zone_fini_rfsproc_v2(zoneid_t zoneid, struct nfs_version_stats *statsp)
207 -{
208 - if (zoneid == GLOBAL_ZONEID)
209 - rfsproccnt_v2_ptr = NULL;
210 - nfsstat_zone_fini_common(zoneid, "nfs", 0, "rfsproccnt_v2");
211 - kmem_free(statsp->rfsproccnt_ptr, sizeof (rfsproccnt_v2_tmpl));
212 -}
213 -
214 175 /*
215 176 * NFSv2 client ACL stats
216 177 */
217 178 static const kstat_named_t aclreqcnt_v2_tmpl[] = {
218 179 { "null", KSTAT_DATA_UINT64 },
219 180 { "getacl", KSTAT_DATA_UINT64 },
220 181 { "setacl", KSTAT_DATA_UINT64 },
221 182 { "getattr", KSTAT_DATA_UINT64 },
222 183 { "access", KSTAT_DATA_UINT64 },
223 184 { "getxattrdir", KSTAT_DATA_UINT64 }
224 185 };
225 186
226 187 static void
227 188 nfsstat_zone_init_aclreq_v2(zoneid_t zoneid, struct nfs_version_stats *statsp)
228 189 {
229 190 statsp->aclreqcnt_ptr = nfsstat_zone_init_common(zoneid, "nfs_acl", 0,
230 191 "aclreqcnt_v2", aclreqcnt_v2_tmpl, sizeof (aclreqcnt_v2_tmpl));
231 192 }
232 193
233 194 static void
234 195 nfsstat_zone_fini_aclreq_v2(zoneid_t zoneid, struct nfs_version_stats *statsp)
235 196 {
236 197 nfsstat_zone_fini_common(zoneid, "nfs_acl", 0, "aclreqcnt_v2");
237 198 kmem_free(statsp->aclreqcnt_ptr, sizeof (aclreqcnt_v2_tmpl));
238 199 }
239 200
240 201 /*
241 202 * NFSv2 server ACL stats
|
↓ open down ↓ |
18 lines elided |
↑ open up ↑ |
242 203 */
243 204 static const kstat_named_t aclproccnt_v2_tmpl[] = {
244 205 { "null", KSTAT_DATA_UINT64 },
245 206 { "getacl", KSTAT_DATA_UINT64 },
246 207 { "setacl", KSTAT_DATA_UINT64 },
247 208 { "getattr", KSTAT_DATA_UINT64 },
248 209 { "access", KSTAT_DATA_UINT64 },
249 210 { "getxattrdir", KSTAT_DATA_UINT64 }
250 211 };
251 212
252 -kstat_named_t *aclproccnt_v2_ptr;
253 -
254 -static void
255 -nfsstat_zone_init_aclproc_v2(zoneid_t zoneid, struct nfs_version_stats *statsp)
256 -{
257 - kstat_named_t *ks_data;
258 -
259 - ks_data = nfsstat_zone_init_common(zoneid, "nfs_acl", 0,
260 - "aclproccnt_v2", aclproccnt_v2_tmpl,
261 - sizeof (aclproccnt_v2_tmpl));
262 - statsp->aclproccnt_ptr = ks_data;
263 - if (zoneid == GLOBAL_ZONEID)
264 - aclproccnt_v2_ptr = ks_data;
265 -}
266 -
267 -static void
268 -nfsstat_zone_fini_aclproc_v2(zoneid_t zoneid, struct nfs_version_stats *statsp)
269 -{
270 - if (zoneid == GLOBAL_ZONEID)
271 - aclproccnt_v2_ptr = NULL;
272 - nfsstat_zone_fini_common(zoneid, "nfs_acl", 0, "aclproccnt_v2");
273 - kmem_free(statsp->aclproccnt_ptr, sizeof (aclproccnt_v2_tmpl));
274 -}
275 -
276 213 /*
277 214 * NFSv3 client stats
278 215 */
279 216 static const kstat_named_t rfsreqcnt_v3_tmpl[] = {
280 217 { "null", KSTAT_DATA_UINT64 },
281 218 { "getattr", KSTAT_DATA_UINT64 },
282 219 { "setattr", KSTAT_DATA_UINT64 },
283 220 { "lookup", KSTAT_DATA_UINT64 },
284 221 { "access", KSTAT_DATA_UINT64 },
285 222 { "readlink", KSTAT_DATA_UINT64 },
286 223 { "read", KSTAT_DATA_UINT64 },
287 224 { "write", KSTAT_DATA_UINT64 },
288 225 { "create", KSTAT_DATA_UINT64 },
289 226 { "mkdir", KSTAT_DATA_UINT64 },
290 227 { "symlink", KSTAT_DATA_UINT64 },
291 228 { "mknod", KSTAT_DATA_UINT64 },
292 229 { "remove", KSTAT_DATA_UINT64 },
293 230 { "rmdir", KSTAT_DATA_UINT64 },
294 231 { "rename", KSTAT_DATA_UINT64 },
295 232 { "link", KSTAT_DATA_UINT64 },
296 233 { "readdir", KSTAT_DATA_UINT64 },
297 234 { "readdirplus", KSTAT_DATA_UINT64 },
298 235 { "fsstat", KSTAT_DATA_UINT64 },
299 236 { "fsinfo", KSTAT_DATA_UINT64 },
300 237 { "pathconf", KSTAT_DATA_UINT64 },
301 238 { "commit", KSTAT_DATA_UINT64 }
302 239 };
303 240
304 241 static void
305 242 nfsstat_zone_init_rfsreq_v3(zoneid_t zoneid, struct nfs_version_stats *statsp)
306 243 {
307 244 statsp->rfsreqcnt_ptr = nfsstat_zone_init_common(zoneid, "nfs", 0,
308 245 "rfsreqcnt_v3", rfsreqcnt_v3_tmpl, sizeof (rfsreqcnt_v3_tmpl));
309 246 }
310 247
311 248 static void
312 249 nfsstat_zone_fini_rfsreq_v3(zoneid_t zoneid, struct nfs_version_stats *statsp)
313 250 {
314 251 nfsstat_zone_fini_common(zoneid, "nfs", 0, "rfsreqcnt_v3");
315 252 kmem_free(statsp->rfsreqcnt_ptr, sizeof (rfsreqcnt_v3_tmpl));
316 253 }
317 254
318 255 /*
319 256 * NFSv3 server stats
320 257 */
321 258 static const kstat_named_t rfsproccnt_v3_tmpl[] = {
322 259 { "null", KSTAT_DATA_UINT64 },
323 260 { "getattr", KSTAT_DATA_UINT64 },
324 261 { "setattr", KSTAT_DATA_UINT64 },
325 262 { "lookup", KSTAT_DATA_UINT64 },
326 263 { "access", KSTAT_DATA_UINT64 },
327 264 { "readlink", KSTAT_DATA_UINT64 },
328 265 { "read", KSTAT_DATA_UINT64 },
329 266 { "write", KSTAT_DATA_UINT64 },
330 267 { "create", KSTAT_DATA_UINT64 },
331 268 { "mkdir", KSTAT_DATA_UINT64 },
332 269 { "symlink", KSTAT_DATA_UINT64 },
333 270 { "mknod", KSTAT_DATA_UINT64 },
334 271 { "remove", KSTAT_DATA_UINT64 },
335 272 { "rmdir", KSTAT_DATA_UINT64 },
|
↓ open down ↓ |
50 lines elided |
↑ open up ↑ |
336 273 { "rename", KSTAT_DATA_UINT64 },
337 274 { "link", KSTAT_DATA_UINT64 },
338 275 { "readdir", KSTAT_DATA_UINT64 },
339 276 { "readdirplus", KSTAT_DATA_UINT64 },
340 277 { "fsstat", KSTAT_DATA_UINT64 },
341 278 { "fsinfo", KSTAT_DATA_UINT64 },
342 279 { "pathconf", KSTAT_DATA_UINT64 },
343 280 { "commit", KSTAT_DATA_UINT64 }
344 281 };
345 282
346 -kstat_named_t *rfsproccnt_v3_ptr;
347 -
348 -static void
349 -nfsstat_zone_init_rfsproc_v3(zoneid_t zoneid, struct nfs_version_stats *statsp)
350 -{
351 - kstat_named_t *ks_data;
352 -
353 - ks_data = nfsstat_zone_init_common(zoneid, "nfs", 0, "rfsproccnt_v3",
354 - rfsproccnt_v3_tmpl, sizeof (rfsproccnt_v3_tmpl));
355 - statsp->rfsproccnt_ptr = ks_data;
356 - if (zoneid == GLOBAL_ZONEID)
357 - rfsproccnt_v3_ptr = ks_data;
358 -}
359 -
360 -static void
361 -nfsstat_zone_fini_rfsproc_v3(zoneid_t zoneid, struct nfs_version_stats *statsp)
362 -{
363 - if (zoneid == GLOBAL_ZONEID)
364 - rfsproccnt_v3_ptr = NULL;
365 - nfsstat_zone_fini_common(zoneid, "nfs", 0, "rfsproccnt_v3");
366 - kmem_free(statsp->rfsproccnt_ptr, sizeof (rfsproccnt_v3_tmpl));
367 -}
368 -
369 283 /*
370 284 * NFSv3 client ACL stats
371 285 */
372 286 static const kstat_named_t aclreqcnt_v3_tmpl[] = {
373 287 { "null", KSTAT_DATA_UINT64 },
374 288 { "getacl", KSTAT_DATA_UINT64 },
375 289 { "setacl", KSTAT_DATA_UINT64 },
376 290 { "getxattrdir", KSTAT_DATA_UINT64 }
377 291 };
378 292
379 293 static void
380 294 nfsstat_zone_init_aclreq_v3(zoneid_t zoneid, struct nfs_version_stats *statsp)
381 295 {
382 296 statsp->aclreqcnt_ptr = nfsstat_zone_init_common(zoneid, "nfs_acl", 0,
383 297 "aclreqcnt_v3", aclreqcnt_v3_tmpl, sizeof (aclreqcnt_v3_tmpl));
384 298 }
385 299
386 300 static void
387 301 nfsstat_zone_fini_aclreq_v3(zoneid_t zoneid, struct nfs_version_stats *statsp)
388 302 {
389 303 nfsstat_zone_fini_common(zoneid, "nfs_acl", 0, "aclreqcnt_v3");
390 304 kmem_free(statsp->aclreqcnt_ptr, sizeof (aclreqcnt_v3_tmpl));
391 305 }
392 306
|
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
393 307 /*
394 308 * NFSv3 server ACL stats
395 309 */
396 310 static const kstat_named_t aclproccnt_v3_tmpl[] = {
397 311 { "null", KSTAT_DATA_UINT64 },
398 312 { "getacl", KSTAT_DATA_UINT64 },
399 313 { "setacl", KSTAT_DATA_UINT64 },
400 314 { "getxattrdir", KSTAT_DATA_UINT64 }
401 315 };
402 316
403 -kstat_named_t *aclproccnt_v3_ptr;
404 -
405 -static void
406 -nfsstat_zone_init_aclproc_v3(zoneid_t zoneid, struct nfs_version_stats *statsp)
407 -{
408 - kstat_named_t *ks_data;
409 -
410 - ks_data = nfsstat_zone_init_common(zoneid, "nfs_acl", 0,
411 - "aclproccnt_v3", aclproccnt_v3_tmpl,
412 - sizeof (aclproccnt_v3_tmpl));
413 - statsp->aclproccnt_ptr = ks_data;
414 - if (zoneid == GLOBAL_ZONEID)
415 - aclproccnt_v3_ptr = ks_data;
416 -}
417 -
418 -static void
419 -nfsstat_zone_fini_aclproc_v3(zoneid_t zoneid, struct nfs_version_stats *statsp)
420 -{
421 - if (zoneid == GLOBAL_ZONEID)
422 - aclproccnt_v3_ptr = NULL;
423 - nfsstat_zone_fini_common(zoneid, "nfs_acl", 0, "aclproccnt_v3");
424 - kmem_free(statsp->aclproccnt_ptr, sizeof (aclproccnt_v3_tmpl));
425 -}
426 -
427 317 /*
428 318 * NFSv4 client stats
429 319 */
430 320 static const kstat_named_t rfsreqcnt_v4_tmpl[] = {
431 321 { "null", KSTAT_DATA_UINT64 },
432 322 { "compound", KSTAT_DATA_UINT64 },
433 323 { "reserved", KSTAT_DATA_UINT64 },
434 324 { "access", KSTAT_DATA_UINT64 },
435 325 { "close", KSTAT_DATA_UINT64 },
436 326 { "commit", KSTAT_DATA_UINT64 },
437 327 { "create", KSTAT_DATA_UINT64 },
438 328 { "delegpurge", KSTAT_DATA_UINT64 },
439 329 { "delegreturn", KSTAT_DATA_UINT64 },
440 330 { "getattr", KSTAT_DATA_UINT64 },
441 331 { "getfh", KSTAT_DATA_UINT64 },
442 332 { "link", KSTAT_DATA_UINT64 },
443 333 { "lock", KSTAT_DATA_UINT64 },
444 334 { "lockt", KSTAT_DATA_UINT64 },
445 335 { "locku", KSTAT_DATA_UINT64 },
446 336 { "lookup", KSTAT_DATA_UINT64 },
447 337 { "lookupp", KSTAT_DATA_UINT64 },
448 338 { "nverify", KSTAT_DATA_UINT64 },
449 339 { "open", KSTAT_DATA_UINT64 },
450 340 { "openattr", KSTAT_DATA_UINT64 },
451 341 { "open_confirm", KSTAT_DATA_UINT64 },
452 342 { "open_downgrade", KSTAT_DATA_UINT64 },
453 343 { "putfh", KSTAT_DATA_UINT64 },
454 344 { "putpubfh", KSTAT_DATA_UINT64 },
455 345 { "putrootfh", KSTAT_DATA_UINT64 },
456 346 { "read", KSTAT_DATA_UINT64 },
457 347 { "readdir", KSTAT_DATA_UINT64 },
458 348 { "readlink", KSTAT_DATA_UINT64 },
459 349 { "remove", KSTAT_DATA_UINT64 },
460 350 { "rename", KSTAT_DATA_UINT64 },
461 351 { "renew", KSTAT_DATA_UINT64 },
462 352 { "restorefh", KSTAT_DATA_UINT64 },
463 353 { "savefh", KSTAT_DATA_UINT64 },
464 354 { "secinfo", KSTAT_DATA_UINT64 },
465 355 { "setattr", KSTAT_DATA_UINT64 },
466 356 { "setclientid", KSTAT_DATA_UINT64 },
467 357 { "setclientid_confirm", KSTAT_DATA_UINT64 },
468 358 { "verify", KSTAT_DATA_UINT64 },
469 359 { "write", KSTAT_DATA_UINT64 }
470 360 };
471 361
472 362 static void
473 363 nfsstat_zone_init_rfsreq_v4(zoneid_t zoneid, struct nfs_version_stats *statsp)
474 364 {
475 365 statsp->rfsreqcnt_ptr = nfsstat_zone_init_common(zoneid, "nfs", 0,
476 366 "rfsreqcnt_v4", rfsreqcnt_v4_tmpl, sizeof (rfsreqcnt_v4_tmpl));
477 367 }
478 368
479 369 static void
480 370 nfsstat_zone_fini_rfsreq_v4(zoneid_t zoneid, struct nfs_version_stats *statsp)
481 371 {
482 372 nfsstat_zone_fini_common(zoneid, "nfs", 0, "rfsreqcnt_v4");
483 373 kmem_free(statsp->rfsreqcnt_ptr, sizeof (rfsreqcnt_v4_tmpl));
484 374 }
485 375
486 376 /*
487 377 * NFSv4 server stats
488 378 */
489 379 static const kstat_named_t rfsproccnt_v4_tmpl[] = {
490 380 { "null", KSTAT_DATA_UINT64 },
491 381 { "compound", KSTAT_DATA_UINT64 },
492 382 { "reserved", KSTAT_DATA_UINT64 },
493 383 { "access", KSTAT_DATA_UINT64 },
494 384 { "close", KSTAT_DATA_UINT64 },
495 385 { "commit", KSTAT_DATA_UINT64 },
496 386 { "create", KSTAT_DATA_UINT64 },
497 387 { "delegpurge", KSTAT_DATA_UINT64 },
498 388 { "delegreturn", KSTAT_DATA_UINT64 },
499 389 { "getattr", KSTAT_DATA_UINT64 },
500 390 { "getfh", KSTAT_DATA_UINT64 },
501 391 { "link", KSTAT_DATA_UINT64 },
502 392 { "lock", KSTAT_DATA_UINT64 },
503 393 { "lockt", KSTAT_DATA_UINT64 },
504 394 { "locku", KSTAT_DATA_UINT64 },
505 395 { "lookup", KSTAT_DATA_UINT64 },
506 396 { "lookupp", KSTAT_DATA_UINT64 },
507 397 { "nverify", KSTAT_DATA_UINT64 },
508 398 { "open", KSTAT_DATA_UINT64 },
509 399 { "openattr", KSTAT_DATA_UINT64 },
510 400 { "open_confirm", KSTAT_DATA_UINT64 },
511 401 { "open_downgrade", KSTAT_DATA_UINT64 },
512 402 { "putfh", KSTAT_DATA_UINT64 },
513 403 { "putpubfh", KSTAT_DATA_UINT64 },
514 404 { "putrootfh", KSTAT_DATA_UINT64 },
515 405 { "read", KSTAT_DATA_UINT64 },
516 406 { "readdir", KSTAT_DATA_UINT64 },
517 407 { "readlink", KSTAT_DATA_UINT64 },
518 408 { "remove", KSTAT_DATA_UINT64 },
519 409 { "rename", KSTAT_DATA_UINT64 },
520 410 { "renew", KSTAT_DATA_UINT64 },
521 411 { "restorefh", KSTAT_DATA_UINT64 },
522 412 { "savefh", KSTAT_DATA_UINT64 },
|
↓ open down ↓ |
86 lines elided |
↑ open up ↑ |
523 413 { "secinfo", KSTAT_DATA_UINT64 },
524 414 { "setattr", KSTAT_DATA_UINT64 },
525 415 { "setclientid", KSTAT_DATA_UINT64 },
526 416 { "setclientid_confirm", KSTAT_DATA_UINT64 },
527 417 { "verify", KSTAT_DATA_UINT64 },
528 418 { "write", KSTAT_DATA_UINT64 },
529 419 { "release_lockowner", KSTAT_DATA_UINT64 },
530 420 { "illegal", KSTAT_DATA_UINT64 },
531 421 };
532 422
533 -kstat_named_t *rfsproccnt_v4_ptr;
534 -
535 -static void
536 -nfsstat_zone_init_rfsproc_v4(zoneid_t zoneid, struct nfs_version_stats *statsp)
537 -{
538 - kstat_named_t *ks_data;
539 -
540 - ks_data = nfsstat_zone_init_common(zoneid, "nfs", 0, "rfsproccnt_v4",
541 - rfsproccnt_v4_tmpl, sizeof (rfsproccnt_v4_tmpl));
542 - statsp->rfsproccnt_ptr = ks_data;
543 - if (zoneid == GLOBAL_ZONEID)
544 - rfsproccnt_v4_ptr = ks_data;
545 -}
546 -
547 -static void
548 -nfsstat_zone_fini_rfsproc_v4(zoneid_t zoneid, struct nfs_version_stats *statsp)
549 -{
550 - if (zoneid == GLOBAL_ZONEID)
551 - rfsproccnt_v4_ptr = NULL;
552 - nfsstat_zone_fini_common(zoneid, "nfs", 0, "rfsproccnt_v4");
553 - kmem_free(statsp->rfsproccnt_ptr, sizeof (rfsproccnt_v4_tmpl));
554 -}
555 -
556 423 /*
557 424 * NFSv4 client ACL stats
558 425 */
559 426 static const kstat_named_t aclreqcnt_v4_tmpl[] = {
560 427 { "null", KSTAT_DATA_UINT64 },
561 428 { "getacl", KSTAT_DATA_UINT64 },
562 429 { "setacl", KSTAT_DATA_UINT64 },
563 430 };
564 431
565 432 static void
566 433 nfsstat_zone_init_aclreq_v4(zoneid_t zoneid, struct nfs_version_stats *statsp)
567 434 {
568 435 statsp->aclreqcnt_ptr = nfsstat_zone_init_common(zoneid, "nfs_acl", 0,
569 436 "aclreqcnt_v4", aclreqcnt_v4_tmpl, sizeof (aclreqcnt_v4_tmpl));
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
570 437 }
571 438
572 439 static void
573 440 nfsstat_zone_fini_aclreq_v4(zoneid_t zoneid, struct nfs_version_stats *statsp)
574 441 {
575 442 nfsstat_zone_fini_common(zoneid, "nfs_acl", 0, "aclreqcnt_v4");
576 443 kmem_free(statsp->aclreqcnt_ptr, sizeof (aclreqcnt_v4_tmpl));
577 444 }
578 445
579 446 /*
580 - * NFSv4 server ACL stats
581 - */
582 -static const kstat_named_t aclproccnt_v4_tmpl[] = {
583 - { "null", KSTAT_DATA_UINT64 },
584 - { "getacl", KSTAT_DATA_UINT64 },
585 - { "setacl", KSTAT_DATA_UINT64 }
586 -};
587 -
588 -kstat_named_t *aclproccnt_v4_ptr;
589 -
590 -static void
591 -nfsstat_zone_init_aclproc_v4(zoneid_t zoneid, struct nfs_version_stats *statsp)
592 -{
593 - kstat_named_t *ks_data;
594 -
595 - ks_data = nfsstat_zone_init_common(zoneid, "nfs_acl", 0,
596 - "aclproccnt_v4", aclproccnt_v4_tmpl,
597 - sizeof (aclproccnt_v4_tmpl));
598 - statsp->aclproccnt_ptr = ks_data;
599 - if (zoneid == GLOBAL_ZONEID)
600 - aclproccnt_v4_ptr = ks_data;
601 -}
602 -
603 -static void
604 -nfsstat_zone_fini_aclproc_v4(zoneid_t zoneid, struct nfs_version_stats *statsp)
605 -{
606 - if (zoneid == GLOBAL_ZONEID)
607 - aclproccnt_v4_ptr = NULL;
608 - nfsstat_zone_fini_common(zoneid, "nfs_acl", 0, "aclproccnt_v4");
609 - kmem_free(statsp->aclproccnt_ptr, sizeof (aclproccnt_v4_tmpl));
610 -}
611 -
612 -/*
613 447 * Zone initializer callback to setup the kstats.
614 448 */
615 449 void *
616 450 nfsstat_zone_init(zoneid_t zoneid)
617 451 {
618 452 struct nfs_stats *nfs_stats_ptr;
619 453
620 454 nfs_stats_ptr = kmem_zalloc(sizeof (*nfs_stats_ptr), KM_SLEEP);
621 455
622 456 /*
623 - * Initialize all versions of the nfs_server
624 - */
625 - nfsstat_zone_init_server(zoneid, nfs_stats_ptr->nfs_stats_svstat_ptr);
626 -
627 - /*
628 457 * Initialize v2 stats
629 458 */
630 459 nfsstat_zone_init_rfsreq_v2(zoneid, &nfs_stats_ptr->nfs_stats_v2);
631 - nfsstat_zone_init_rfsproc_v2(zoneid, &nfs_stats_ptr->nfs_stats_v2);
632 460 nfsstat_zone_init_aclreq_v2(zoneid, &nfs_stats_ptr->nfs_stats_v2);
633 - nfsstat_zone_init_aclproc_v2(zoneid, &nfs_stats_ptr->nfs_stats_v2);
634 461 /*
635 462 * Initialize v3 stats
636 463 */
637 464 nfsstat_zone_init_rfsreq_v3(zoneid, &nfs_stats_ptr->nfs_stats_v3);
638 - nfsstat_zone_init_rfsproc_v3(zoneid, &nfs_stats_ptr->nfs_stats_v3);
639 465 nfsstat_zone_init_aclreq_v3(zoneid, &nfs_stats_ptr->nfs_stats_v3);
640 - nfsstat_zone_init_aclproc_v3(zoneid, &nfs_stats_ptr->nfs_stats_v3);
641 466 /*
642 467 * Initialize v4 stats
643 468 */
644 469 nfsstat_zone_init_rfsreq_v4(zoneid, &nfs_stats_ptr->nfs_stats_v4);
645 - nfsstat_zone_init_rfsproc_v4(zoneid, &nfs_stats_ptr->nfs_stats_v4);
646 470 nfsstat_zone_init_aclreq_v4(zoneid, &nfs_stats_ptr->nfs_stats_v4);
647 - nfsstat_zone_init_aclproc_v4(zoneid, &nfs_stats_ptr->nfs_stats_v4);
648 471
649 472 return (nfs_stats_ptr);
650 473 }
651 474
652 475 /*
653 476 * Zone destructor callback to tear down the various kstats.
654 477 */
655 478 void
656 479 nfsstat_zone_fini(zoneid_t zoneid, void *data)
657 480 {
658 481 struct nfs_stats *nfs_stats_ptr = data;
659 482
660 483 /*
661 - * Free nfs:0:nfs_server stats
662 - */
663 - nfsstat_zone_fini_server(zoneid, nfs_stats_ptr->nfs_stats_svstat_ptr);
664 -
665 - /*
666 484 * Free v2 stats
667 485 */
668 486 nfsstat_zone_fini_rfsreq_v2(zoneid, &nfs_stats_ptr->nfs_stats_v2);
669 - nfsstat_zone_fini_rfsproc_v2(zoneid, &nfs_stats_ptr->nfs_stats_v2);
670 487 nfsstat_zone_fini_aclreq_v2(zoneid, &nfs_stats_ptr->nfs_stats_v2);
671 - nfsstat_zone_fini_aclproc_v2(zoneid, &nfs_stats_ptr->nfs_stats_v2);
672 488 /*
673 489 * Free v3 stats
674 490 */
675 491 nfsstat_zone_fini_rfsreq_v3(zoneid, &nfs_stats_ptr->nfs_stats_v3);
676 - nfsstat_zone_fini_rfsproc_v3(zoneid, &nfs_stats_ptr->nfs_stats_v3);
677 492 nfsstat_zone_fini_aclreq_v3(zoneid, &nfs_stats_ptr->nfs_stats_v3);
678 - nfsstat_zone_fini_aclproc_v3(zoneid, &nfs_stats_ptr->nfs_stats_v3);
679 493 /*
680 494 * Free v4 stats
681 495 */
682 496 nfsstat_zone_fini_rfsreq_v4(zoneid, &nfs_stats_ptr->nfs_stats_v4);
683 - nfsstat_zone_fini_rfsproc_v4(zoneid, &nfs_stats_ptr->nfs_stats_v4);
684 497 nfsstat_zone_fini_aclreq_v4(zoneid, &nfs_stats_ptr->nfs_stats_v4);
685 - nfsstat_zone_fini_aclproc_v4(zoneid, &nfs_stats_ptr->nfs_stats_v4);
686 498
687 499 kmem_free(nfs_stats_ptr, sizeof (*nfs_stats_ptr));
500 +}
501 +
502 +void
503 +rfs_stat_zone_init(nfs_globals_t *ng)
504 +{
505 + zoneid_t zoneid = ng->nfs_zoneid;
506 +
507 + /* Initialize all versions of the nfs_server */
508 + nfsstat_zone_init_server(zoneid, ng->svstat);
509 +
510 + /* NFS proc */
511 + ng->rfsproccnt[NFS_V2] = nfsstat_zone_init_common(zoneid, "nfs", 0,
512 + "rfsproccnt_v2", rfsproccnt_v2_tmpl, sizeof (rfsproccnt_v2_tmpl));
513 +
514 + ng->rfsproccnt[NFS_V3] = nfsstat_zone_init_common(zoneid, "nfs", 0,
515 + "rfsproccnt_v3", rfsproccnt_v3_tmpl, sizeof (rfsproccnt_v3_tmpl));
516 +
517 + ng->rfsproccnt[NFS_V4] = nfsstat_zone_init_common(zoneid, "nfs", 0,
518 + "rfsproccnt_v4", rfsproccnt_v4_tmpl, sizeof (rfsproccnt_v4_tmpl));
519 +
520 + /* ACL proc */
521 + ng->aclproccnt[NFS_V2] = nfsstat_zone_init_common(zoneid, "nfs_acl", 0,
522 + "aclproccnt_v2", aclproccnt_v2_tmpl, sizeof (aclproccnt_v2_tmpl));
523 +
524 + ng->aclproccnt[NFS_V3] = nfsstat_zone_init_common(zoneid, "nfs_acl", 0,
525 + "aclproccnt_v3", aclproccnt_v3_tmpl, sizeof (aclproccnt_v3_tmpl));
526 +
527 +}
528 +
529 +void
530 +rfs_stat_zone_fini(nfs_globals_t *ng)
531 +{
532 + zoneid_t zoneid = ng->nfs_zoneid;
533 +
534 + /* Free nfs:x:nfs_server stats */
535 + nfsstat_zone_fini_server(zoneid, ng->svstat);
536 +
537 + /* NFS */
538 + nfsstat_zone_fini_common(zoneid, "nfs", 0, "rfsproccnt_v2");
539 + kmem_free(ng->rfsproccnt[NFS_V2], sizeof (rfsproccnt_v2_tmpl));
540 +
541 + nfsstat_zone_fini_common(zoneid, "nfs", 0, "rfsproccnt_v3");
542 + kmem_free(ng->rfsproccnt[NFS_V3], sizeof (rfsproccnt_v3_tmpl));
543 +
544 + nfsstat_zone_fini_common(zoneid, "nfs", 0, "rfsproccnt_v4");
545 + kmem_free(ng->rfsproccnt[NFS_V4], sizeof (rfsproccnt_v4_tmpl));
546 +
547 + /* ACL */
548 + nfsstat_zone_fini_common(zoneid, "nfs_acl", 0, "aclproccnt_v2");
549 + kmem_free(ng->aclproccnt[NFS_V2], sizeof (aclproccnt_v2_tmpl));
550 +
551 + nfsstat_zone_fini_common(zoneid, "nfs_acl", 0, "aclproccnt_v3");
552 + kmem_free(ng->aclproccnt[NFS_V3], sizeof (aclproccnt_v3_tmpl));
553 +
688 554 }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX