72 {
73 kstat_delete_byname_zone(module, vers, name, zoneid);
74 }
75
76 /*
77 * Server statistics. These are defined here, rather than in the server
78 * code, so that they can be referenced before the nfssrv kmod is loaded.
79 *
80 * The "calls" counter is a Contract Private interface covered by
81 * PSARC/2001/357. Please contact contract-2001-357-01@eng.sun.com before
82 * making any changes.
83 */
84
85 static const kstat_named_t svstat_tmpl[] = {
86 { "calls", KSTAT_DATA_UINT64 },
87 { "badcalls", KSTAT_DATA_UINT64 },
88 { "referrals", KSTAT_DATA_UINT64 },
89 { "referlinks", KSTAT_DATA_UINT64 },
90 };
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 static void
96 nfsstat_zone_init_server(zoneid_t zoneid, kstat_named_t *svstatp[])
97 {
98 int vers;
99
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 for (vers = NFS_VERSION; vers <= NFS_V4; vers++) {
110 svstatp[vers] = nfsstat_zone_init_common(zoneid, "nfs", vers,
111 "nfs_server", svstat_tmpl, sizeof (svstat_tmpl));
112 if (zoneid == GLOBAL_ZONEID)
113 global_svstat_ptr[vers] = svstatp[vers];
114 }
115 }
116
117 static void
118 nfsstat_zone_fini_server(zoneid_t zoneid, kstat_named_t **svstatp)
119 {
120 int vers;
121 for (vers = NFS_VERSION; vers <= NFS_V4; vers++) {
122 if (zoneid == GLOBAL_ZONEID)
123 global_svstat_ptr[vers] = NULL;
124 nfsstat_zone_fini_common(zoneid, "nfs", vers, "nfs_server");
125 kmem_free(svstatp[vers], sizeof (svstat_tmpl));
126 }
127 }
128
129 /*
130 * NFSv2 client stats
131 */
132 static const kstat_named_t rfsreqcnt_v2_tmpl[] = {
133 { "null", KSTAT_DATA_UINT64 },
134 { "getattr", KSTAT_DATA_UINT64 },
135 { "setattr", KSTAT_DATA_UINT64 },
136 { "root", KSTAT_DATA_UINT64 },
137 { "lookup", KSTAT_DATA_UINT64 },
138 { "readlink", KSTAT_DATA_UINT64 },
139 { "read", KSTAT_DATA_UINT64 },
140 { "wrcache", KSTAT_DATA_UINT64 },
141 { "write", KSTAT_DATA_UINT64 },
142 { "create", KSTAT_DATA_UINT64 },
143 { "remove", KSTAT_DATA_UINT64 },
171 { "null", KSTAT_DATA_UINT64 },
172 { "getattr", KSTAT_DATA_UINT64 },
173 { "setattr", KSTAT_DATA_UINT64 },
174 { "root", KSTAT_DATA_UINT64 },
175 { "lookup", KSTAT_DATA_UINT64 },
176 { "readlink", KSTAT_DATA_UINT64 },
177 { "read", KSTAT_DATA_UINT64 },
178 { "wrcache", KSTAT_DATA_UINT64 },
179 { "write", KSTAT_DATA_UINT64 },
180 { "create", KSTAT_DATA_UINT64 },
181 { "remove", KSTAT_DATA_UINT64 },
182 { "rename", KSTAT_DATA_UINT64 },
183 { "link", KSTAT_DATA_UINT64 },
184 { "symlink", KSTAT_DATA_UINT64 },
185 { "mkdir", KSTAT_DATA_UINT64 },
186 { "rmdir", KSTAT_DATA_UINT64 },
187 { "readdir", KSTAT_DATA_UINT64 },
188 { "statfs", KSTAT_DATA_UINT64 }
189 };
190
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 /*
215 * NFSv2 client ACL stats
216 */
217 static const kstat_named_t aclreqcnt_v2_tmpl[] = {
218 { "null", KSTAT_DATA_UINT64 },
219 { "getacl", KSTAT_DATA_UINT64 },
220 { "setacl", KSTAT_DATA_UINT64 },
221 { "getattr", KSTAT_DATA_UINT64 },
222 { "access", KSTAT_DATA_UINT64 },
223 { "getxattrdir", KSTAT_DATA_UINT64 }
224 };
225
226 static void
227 nfsstat_zone_init_aclreq_v2(zoneid_t zoneid, struct nfs_version_stats *statsp)
228 {
229 statsp->aclreqcnt_ptr = nfsstat_zone_init_common(zoneid, "nfs_acl", 0,
230 "aclreqcnt_v2", aclreqcnt_v2_tmpl, sizeof (aclreqcnt_v2_tmpl));
231 }
232
233 static void
234 nfsstat_zone_fini_aclreq_v2(zoneid_t zoneid, struct nfs_version_stats *statsp)
235 {
236 nfsstat_zone_fini_common(zoneid, "nfs_acl", 0, "aclreqcnt_v2");
237 kmem_free(statsp->aclreqcnt_ptr, sizeof (aclreqcnt_v2_tmpl));
238 }
239
240 /*
241 * NFSv2 server ACL stats
242 */
243 static const kstat_named_t aclproccnt_v2_tmpl[] = {
244 { "null", KSTAT_DATA_UINT64 },
245 { "getacl", KSTAT_DATA_UINT64 },
246 { "setacl", KSTAT_DATA_UINT64 },
247 { "getattr", KSTAT_DATA_UINT64 },
248 { "access", KSTAT_DATA_UINT64 },
249 { "getxattrdir", KSTAT_DATA_UINT64 }
250 };
251
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 /*
277 * NFSv3 client stats
278 */
279 static const kstat_named_t rfsreqcnt_v3_tmpl[] = {
280 { "null", KSTAT_DATA_UINT64 },
281 { "getattr", KSTAT_DATA_UINT64 },
282 { "setattr", KSTAT_DATA_UINT64 },
283 { "lookup", KSTAT_DATA_UINT64 },
284 { "access", KSTAT_DATA_UINT64 },
285 { "readlink", KSTAT_DATA_UINT64 },
286 { "read", KSTAT_DATA_UINT64 },
287 { "write", KSTAT_DATA_UINT64 },
288 { "create", KSTAT_DATA_UINT64 },
289 { "mkdir", KSTAT_DATA_UINT64 },
290 { "symlink", KSTAT_DATA_UINT64 },
291 { "mknod", KSTAT_DATA_UINT64 },
292 { "remove", KSTAT_DATA_UINT64 },
293 { "rmdir", KSTAT_DATA_UINT64 },
294 { "rename", KSTAT_DATA_UINT64 },
295 { "link", KSTAT_DATA_UINT64 },
326 { "access", KSTAT_DATA_UINT64 },
327 { "readlink", KSTAT_DATA_UINT64 },
328 { "read", KSTAT_DATA_UINT64 },
329 { "write", KSTAT_DATA_UINT64 },
330 { "create", KSTAT_DATA_UINT64 },
331 { "mkdir", KSTAT_DATA_UINT64 },
332 { "symlink", KSTAT_DATA_UINT64 },
333 { "mknod", KSTAT_DATA_UINT64 },
334 { "remove", KSTAT_DATA_UINT64 },
335 { "rmdir", KSTAT_DATA_UINT64 },
336 { "rename", KSTAT_DATA_UINT64 },
337 { "link", KSTAT_DATA_UINT64 },
338 { "readdir", KSTAT_DATA_UINT64 },
339 { "readdirplus", KSTAT_DATA_UINT64 },
340 { "fsstat", KSTAT_DATA_UINT64 },
341 { "fsinfo", KSTAT_DATA_UINT64 },
342 { "pathconf", KSTAT_DATA_UINT64 },
343 { "commit", KSTAT_DATA_UINT64 }
344 };
345
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 /*
370 * NFSv3 client ACL stats
371 */
372 static const kstat_named_t aclreqcnt_v3_tmpl[] = {
373 { "null", KSTAT_DATA_UINT64 },
374 { "getacl", KSTAT_DATA_UINT64 },
375 { "setacl", KSTAT_DATA_UINT64 },
376 { "getxattrdir", KSTAT_DATA_UINT64 }
377 };
378
379 static void
380 nfsstat_zone_init_aclreq_v3(zoneid_t zoneid, struct nfs_version_stats *statsp)
381 {
382 statsp->aclreqcnt_ptr = nfsstat_zone_init_common(zoneid, "nfs_acl", 0,
383 "aclreqcnt_v3", aclreqcnt_v3_tmpl, sizeof (aclreqcnt_v3_tmpl));
384 }
385
386 static void
387 nfsstat_zone_fini_aclreq_v3(zoneid_t zoneid, struct nfs_version_stats *statsp)
388 {
389 nfsstat_zone_fini_common(zoneid, "nfs_acl", 0, "aclreqcnt_v3");
390 kmem_free(statsp->aclreqcnt_ptr, sizeof (aclreqcnt_v3_tmpl));
391 }
392
393 /*
394 * NFSv3 server ACL stats
395 */
396 static const kstat_named_t aclproccnt_v3_tmpl[] = {
397 { "null", KSTAT_DATA_UINT64 },
398 { "getacl", KSTAT_DATA_UINT64 },
399 { "setacl", KSTAT_DATA_UINT64 },
400 { "getxattrdir", KSTAT_DATA_UINT64 }
401 };
402
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 /*
428 * NFSv4 client stats
429 */
430 static const kstat_named_t rfsreqcnt_v4_tmpl[] = {
431 { "null", KSTAT_DATA_UINT64 },
432 { "compound", KSTAT_DATA_UINT64 },
433 { "reserved", KSTAT_DATA_UINT64 },
434 { "access", KSTAT_DATA_UINT64 },
435 { "close", KSTAT_DATA_UINT64 },
436 { "commit", KSTAT_DATA_UINT64 },
437 { "create", KSTAT_DATA_UINT64 },
438 { "delegpurge", KSTAT_DATA_UINT64 },
439 { "delegreturn", KSTAT_DATA_UINT64 },
440 { "getattr", KSTAT_DATA_UINT64 },
441 { "getfh", KSTAT_DATA_UINT64 },
442 { "link", KSTAT_DATA_UINT64 },
443 { "lock", KSTAT_DATA_UINT64 },
444 { "lockt", KSTAT_DATA_UINT64 },
445 { "locku", KSTAT_DATA_UINT64 },
446 { "lookup", KSTAT_DATA_UINT64 },
513 { "putpubfh", KSTAT_DATA_UINT64 },
514 { "putrootfh", KSTAT_DATA_UINT64 },
515 { "read", KSTAT_DATA_UINT64 },
516 { "readdir", KSTAT_DATA_UINT64 },
517 { "readlink", KSTAT_DATA_UINT64 },
518 { "remove", KSTAT_DATA_UINT64 },
519 { "rename", KSTAT_DATA_UINT64 },
520 { "renew", KSTAT_DATA_UINT64 },
521 { "restorefh", KSTAT_DATA_UINT64 },
522 { "savefh", KSTAT_DATA_UINT64 },
523 { "secinfo", KSTAT_DATA_UINT64 },
524 { "setattr", KSTAT_DATA_UINT64 },
525 { "setclientid", KSTAT_DATA_UINT64 },
526 { "setclientid_confirm", KSTAT_DATA_UINT64 },
527 { "verify", KSTAT_DATA_UINT64 },
528 { "write", KSTAT_DATA_UINT64 },
529 { "release_lockowner", KSTAT_DATA_UINT64 },
530 { "illegal", KSTAT_DATA_UINT64 },
531 };
532
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 /*
557 * NFSv4 client ACL stats
558 */
559 static const kstat_named_t aclreqcnt_v4_tmpl[] = {
560 { "null", KSTAT_DATA_UINT64 },
561 { "getacl", KSTAT_DATA_UINT64 },
562 { "setacl", KSTAT_DATA_UINT64 },
563 };
564
565 static void
566 nfsstat_zone_init_aclreq_v4(zoneid_t zoneid, struct nfs_version_stats *statsp)
567 {
568 statsp->aclreqcnt_ptr = nfsstat_zone_init_common(zoneid, "nfs_acl", 0,
569 "aclreqcnt_v4", aclreqcnt_v4_tmpl, sizeof (aclreqcnt_v4_tmpl));
570 }
571
572 static void
573 nfsstat_zone_fini_aclreq_v4(zoneid_t zoneid, struct nfs_version_stats *statsp)
574 {
575 nfsstat_zone_fini_common(zoneid, "nfs_acl", 0, "aclreqcnt_v4");
576 kmem_free(statsp->aclreqcnt_ptr, sizeof (aclreqcnt_v4_tmpl));
577 }
578
579 /*
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 * Zone initializer callback to setup the kstats.
614 */
615 void *
616 nfsstat_zone_init(zoneid_t zoneid)
617 {
618 struct nfs_stats *nfs_stats_ptr;
619
620 nfs_stats_ptr = kmem_zalloc(sizeof (*nfs_stats_ptr), KM_SLEEP);
621
622 /*
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 * Initialize v2 stats
629 */
630 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 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 /*
635 * Initialize v3 stats
636 */
637 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 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 /*
642 * Initialize v4 stats
643 */
644 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 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
649 return (nfs_stats_ptr);
650 }
651
652 /*
653 * Zone destructor callback to tear down the various kstats.
654 */
655 void
656 nfsstat_zone_fini(zoneid_t zoneid, void *data)
657 {
658 struct nfs_stats *nfs_stats_ptr = data;
659
660 /*
661 * Free nfs:0:nfs_server stats
662 */
663 nfsstat_zone_fini_server(zoneid, nfs_stats_ptr->nfs_stats_svstat_ptr);
664
665 /*
666 * Free v2 stats
667 */
668 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 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 /*
673 * Free v3 stats
674 */
675 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 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 /*
680 * Free v4 stats
681 */
682 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 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
687 kmem_free(nfs_stats_ptr, sizeof (*nfs_stats_ptr));
688 }
|
72 {
73 kstat_delete_byname_zone(module, vers, name, zoneid);
74 }
75
76 /*
77 * Server statistics. These are defined here, rather than in the server
78 * code, so that they can be referenced before the nfssrv kmod is loaded.
79 *
80 * The "calls" counter is a Contract Private interface covered by
81 * PSARC/2001/357. Please contact contract-2001-357-01@eng.sun.com before
82 * making any changes.
83 */
84
85 static const kstat_named_t svstat_tmpl[] = {
86 { "calls", KSTAT_DATA_UINT64 },
87 { "badcalls", KSTAT_DATA_UINT64 },
88 { "referrals", KSTAT_DATA_UINT64 },
89 { "referlinks", KSTAT_DATA_UINT64 },
90 };
91
92 static void
93 nfsstat_zone_init_server(zoneid_t zoneid, kstat_named_t *svstatp[])
94 {
95 int vers;
96
97 for (vers = NFS_VERSION; vers <= NFS_V4; vers++) {
98 svstatp[vers] = nfsstat_zone_init_common(zoneid, "nfs", vers,
99 "nfs_server", svstat_tmpl, sizeof (svstat_tmpl));
100 }
101 }
102
103 static void
104 nfsstat_zone_fini_server(zoneid_t zoneid, kstat_named_t *svstatp[])
105 {
106 int vers;
107 for (vers = NFS_VERSION; vers <= NFS_V4; vers++) {
108 nfsstat_zone_fini_common(zoneid, "nfs", vers, "nfs_server");
109 kmem_free(svstatp[vers], sizeof (svstat_tmpl));
110 }
111 }
112
113 /*
114 * NFSv2 client stats
115 */
116 static const kstat_named_t rfsreqcnt_v2_tmpl[] = {
117 { "null", KSTAT_DATA_UINT64 },
118 { "getattr", KSTAT_DATA_UINT64 },
119 { "setattr", KSTAT_DATA_UINT64 },
120 { "root", KSTAT_DATA_UINT64 },
121 { "lookup", KSTAT_DATA_UINT64 },
122 { "readlink", KSTAT_DATA_UINT64 },
123 { "read", KSTAT_DATA_UINT64 },
124 { "wrcache", KSTAT_DATA_UINT64 },
125 { "write", KSTAT_DATA_UINT64 },
126 { "create", KSTAT_DATA_UINT64 },
127 { "remove", KSTAT_DATA_UINT64 },
155 { "null", KSTAT_DATA_UINT64 },
156 { "getattr", KSTAT_DATA_UINT64 },
157 { "setattr", KSTAT_DATA_UINT64 },
158 { "root", KSTAT_DATA_UINT64 },
159 { "lookup", KSTAT_DATA_UINT64 },
160 { "readlink", KSTAT_DATA_UINT64 },
161 { "read", KSTAT_DATA_UINT64 },
162 { "wrcache", KSTAT_DATA_UINT64 },
163 { "write", KSTAT_DATA_UINT64 },
164 { "create", KSTAT_DATA_UINT64 },
165 { "remove", KSTAT_DATA_UINT64 },
166 { "rename", KSTAT_DATA_UINT64 },
167 { "link", KSTAT_DATA_UINT64 },
168 { "symlink", KSTAT_DATA_UINT64 },
169 { "mkdir", KSTAT_DATA_UINT64 },
170 { "rmdir", KSTAT_DATA_UINT64 },
171 { "readdir", KSTAT_DATA_UINT64 },
172 { "statfs", KSTAT_DATA_UINT64 }
173 };
174
175 /*
176 * NFSv2 client ACL stats
177 */
178 static const kstat_named_t aclreqcnt_v2_tmpl[] = {
179 { "null", KSTAT_DATA_UINT64 },
180 { "getacl", KSTAT_DATA_UINT64 },
181 { "setacl", KSTAT_DATA_UINT64 },
182 { "getattr", KSTAT_DATA_UINT64 },
183 { "access", KSTAT_DATA_UINT64 },
184 { "getxattrdir", KSTAT_DATA_UINT64 }
185 };
186
187 static void
188 nfsstat_zone_init_aclreq_v2(zoneid_t zoneid, struct nfs_version_stats *statsp)
189 {
190 statsp->aclreqcnt_ptr = nfsstat_zone_init_common(zoneid, "nfs_acl", 0,
191 "aclreqcnt_v2", aclreqcnt_v2_tmpl, sizeof (aclreqcnt_v2_tmpl));
192 }
193
194 static void
195 nfsstat_zone_fini_aclreq_v2(zoneid_t zoneid, struct nfs_version_stats *statsp)
196 {
197 nfsstat_zone_fini_common(zoneid, "nfs_acl", 0, "aclreqcnt_v2");
198 kmem_free(statsp->aclreqcnt_ptr, sizeof (aclreqcnt_v2_tmpl));
199 }
200
201 /*
202 * NFSv2 server ACL stats
203 */
204 static const kstat_named_t aclproccnt_v2_tmpl[] = {
205 { "null", KSTAT_DATA_UINT64 },
206 { "getacl", KSTAT_DATA_UINT64 },
207 { "setacl", KSTAT_DATA_UINT64 },
208 { "getattr", KSTAT_DATA_UINT64 },
209 { "access", KSTAT_DATA_UINT64 },
210 { "getxattrdir", KSTAT_DATA_UINT64 }
211 };
212
213 /*
214 * NFSv3 client stats
215 */
216 static const kstat_named_t rfsreqcnt_v3_tmpl[] = {
217 { "null", KSTAT_DATA_UINT64 },
218 { "getattr", KSTAT_DATA_UINT64 },
219 { "setattr", KSTAT_DATA_UINT64 },
220 { "lookup", KSTAT_DATA_UINT64 },
221 { "access", KSTAT_DATA_UINT64 },
222 { "readlink", KSTAT_DATA_UINT64 },
223 { "read", KSTAT_DATA_UINT64 },
224 { "write", KSTAT_DATA_UINT64 },
225 { "create", KSTAT_DATA_UINT64 },
226 { "mkdir", KSTAT_DATA_UINT64 },
227 { "symlink", KSTAT_DATA_UINT64 },
228 { "mknod", KSTAT_DATA_UINT64 },
229 { "remove", KSTAT_DATA_UINT64 },
230 { "rmdir", KSTAT_DATA_UINT64 },
231 { "rename", KSTAT_DATA_UINT64 },
232 { "link", KSTAT_DATA_UINT64 },
263 { "access", KSTAT_DATA_UINT64 },
264 { "readlink", KSTAT_DATA_UINT64 },
265 { "read", KSTAT_DATA_UINT64 },
266 { "write", KSTAT_DATA_UINT64 },
267 { "create", KSTAT_DATA_UINT64 },
268 { "mkdir", KSTAT_DATA_UINT64 },
269 { "symlink", KSTAT_DATA_UINT64 },
270 { "mknod", KSTAT_DATA_UINT64 },
271 { "remove", KSTAT_DATA_UINT64 },
272 { "rmdir", KSTAT_DATA_UINT64 },
273 { "rename", KSTAT_DATA_UINT64 },
274 { "link", KSTAT_DATA_UINT64 },
275 { "readdir", KSTAT_DATA_UINT64 },
276 { "readdirplus", KSTAT_DATA_UINT64 },
277 { "fsstat", KSTAT_DATA_UINT64 },
278 { "fsinfo", KSTAT_DATA_UINT64 },
279 { "pathconf", KSTAT_DATA_UINT64 },
280 { "commit", KSTAT_DATA_UINT64 }
281 };
282
283 /*
284 * NFSv3 client ACL stats
285 */
286 static const kstat_named_t aclreqcnt_v3_tmpl[] = {
287 { "null", KSTAT_DATA_UINT64 },
288 { "getacl", KSTAT_DATA_UINT64 },
289 { "setacl", KSTAT_DATA_UINT64 },
290 { "getxattrdir", KSTAT_DATA_UINT64 }
291 };
292
293 static void
294 nfsstat_zone_init_aclreq_v3(zoneid_t zoneid, struct nfs_version_stats *statsp)
295 {
296 statsp->aclreqcnt_ptr = nfsstat_zone_init_common(zoneid, "nfs_acl", 0,
297 "aclreqcnt_v3", aclreqcnt_v3_tmpl, sizeof (aclreqcnt_v3_tmpl));
298 }
299
300 static void
301 nfsstat_zone_fini_aclreq_v3(zoneid_t zoneid, struct nfs_version_stats *statsp)
302 {
303 nfsstat_zone_fini_common(zoneid, "nfs_acl", 0, "aclreqcnt_v3");
304 kmem_free(statsp->aclreqcnt_ptr, sizeof (aclreqcnt_v3_tmpl));
305 }
306
307 /*
308 * NFSv3 server ACL stats
309 */
310 static const kstat_named_t aclproccnt_v3_tmpl[] = {
311 { "null", KSTAT_DATA_UINT64 },
312 { "getacl", KSTAT_DATA_UINT64 },
313 { "setacl", KSTAT_DATA_UINT64 },
314 { "getxattrdir", KSTAT_DATA_UINT64 }
315 };
316
317 /*
318 * NFSv4 client stats
319 */
320 static const kstat_named_t rfsreqcnt_v4_tmpl[] = {
321 { "null", KSTAT_DATA_UINT64 },
322 { "compound", KSTAT_DATA_UINT64 },
323 { "reserved", KSTAT_DATA_UINT64 },
324 { "access", KSTAT_DATA_UINT64 },
325 { "close", KSTAT_DATA_UINT64 },
326 { "commit", KSTAT_DATA_UINT64 },
327 { "create", KSTAT_DATA_UINT64 },
328 { "delegpurge", KSTAT_DATA_UINT64 },
329 { "delegreturn", KSTAT_DATA_UINT64 },
330 { "getattr", KSTAT_DATA_UINT64 },
331 { "getfh", KSTAT_DATA_UINT64 },
332 { "link", KSTAT_DATA_UINT64 },
333 { "lock", KSTAT_DATA_UINT64 },
334 { "lockt", KSTAT_DATA_UINT64 },
335 { "locku", KSTAT_DATA_UINT64 },
336 { "lookup", KSTAT_DATA_UINT64 },
403 { "putpubfh", KSTAT_DATA_UINT64 },
404 { "putrootfh", KSTAT_DATA_UINT64 },
405 { "read", KSTAT_DATA_UINT64 },
406 { "readdir", KSTAT_DATA_UINT64 },
407 { "readlink", KSTAT_DATA_UINT64 },
408 { "remove", KSTAT_DATA_UINT64 },
409 { "rename", KSTAT_DATA_UINT64 },
410 { "renew", KSTAT_DATA_UINT64 },
411 { "restorefh", KSTAT_DATA_UINT64 },
412 { "savefh", KSTAT_DATA_UINT64 },
413 { "secinfo", KSTAT_DATA_UINT64 },
414 { "setattr", KSTAT_DATA_UINT64 },
415 { "setclientid", KSTAT_DATA_UINT64 },
416 { "setclientid_confirm", KSTAT_DATA_UINT64 },
417 { "verify", KSTAT_DATA_UINT64 },
418 { "write", KSTAT_DATA_UINT64 },
419 { "release_lockowner", KSTAT_DATA_UINT64 },
420 { "illegal", KSTAT_DATA_UINT64 },
421 };
422
423 /*
424 * NFSv4 client ACL stats
425 */
426 static const kstat_named_t aclreqcnt_v4_tmpl[] = {
427 { "null", KSTAT_DATA_UINT64 },
428 { "getacl", KSTAT_DATA_UINT64 },
429 { "setacl", KSTAT_DATA_UINT64 },
430 };
431
432 static void
433 nfsstat_zone_init_aclreq_v4(zoneid_t zoneid, struct nfs_version_stats *statsp)
434 {
435 statsp->aclreqcnt_ptr = nfsstat_zone_init_common(zoneid, "nfs_acl", 0,
436 "aclreqcnt_v4", aclreqcnt_v4_tmpl, sizeof (aclreqcnt_v4_tmpl));
437 }
438
439 static void
440 nfsstat_zone_fini_aclreq_v4(zoneid_t zoneid, struct nfs_version_stats *statsp)
441 {
442 nfsstat_zone_fini_common(zoneid, "nfs_acl", 0, "aclreqcnt_v4");
443 kmem_free(statsp->aclreqcnt_ptr, sizeof (aclreqcnt_v4_tmpl));
444 }
445
446 /*
447 * Zone initializer callback to setup the kstats.
448 */
449 void *
450 nfsstat_zone_init(zoneid_t zoneid)
451 {
452 struct nfs_stats *nfs_stats_ptr;
453
454 nfs_stats_ptr = kmem_zalloc(sizeof (*nfs_stats_ptr), KM_SLEEP);
455
456 /*
457 * Initialize v2 stats
458 */
459 nfsstat_zone_init_rfsreq_v2(zoneid, &nfs_stats_ptr->nfs_stats_v2);
460 nfsstat_zone_init_aclreq_v2(zoneid, &nfs_stats_ptr->nfs_stats_v2);
461 /*
462 * Initialize v3 stats
463 */
464 nfsstat_zone_init_rfsreq_v3(zoneid, &nfs_stats_ptr->nfs_stats_v3);
465 nfsstat_zone_init_aclreq_v3(zoneid, &nfs_stats_ptr->nfs_stats_v3);
466 /*
467 * Initialize v4 stats
468 */
469 nfsstat_zone_init_rfsreq_v4(zoneid, &nfs_stats_ptr->nfs_stats_v4);
470 nfsstat_zone_init_aclreq_v4(zoneid, &nfs_stats_ptr->nfs_stats_v4);
471
472 return (nfs_stats_ptr);
473 }
474
475 /*
476 * Zone destructor callback to tear down the various kstats.
477 */
478 void
479 nfsstat_zone_fini(zoneid_t zoneid, void *data)
480 {
481 struct nfs_stats *nfs_stats_ptr = data;
482
483 /*
484 * Free v2 stats
485 */
486 nfsstat_zone_fini_rfsreq_v2(zoneid, &nfs_stats_ptr->nfs_stats_v2);
487 nfsstat_zone_fini_aclreq_v2(zoneid, &nfs_stats_ptr->nfs_stats_v2);
488 /*
489 * Free v3 stats
490 */
491 nfsstat_zone_fini_rfsreq_v3(zoneid, &nfs_stats_ptr->nfs_stats_v3);
492 nfsstat_zone_fini_aclreq_v3(zoneid, &nfs_stats_ptr->nfs_stats_v3);
493 /*
494 * Free v4 stats
495 */
496 nfsstat_zone_fini_rfsreq_v4(zoneid, &nfs_stats_ptr->nfs_stats_v4);
497 nfsstat_zone_fini_aclreq_v4(zoneid, &nfs_stats_ptr->nfs_stats_v4);
498
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
554 }
|