kernel/fs/nfs/nfs_stats.c

   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 (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #include <sys/types.h>
  27 #include <sys/kstat.h>
  28 #include <sys/zone.h>
  29 #include <sys/kmem.h>
  30 #include <sys/systm.h>
  31
  32 #include <nfs/nfs.h>
  33 #include <nfs/nfs4_kprot.h>
  34
  35 /*
  36  * Key to retrieve per-zone data corresponding to NFS kstats consumed by
  37  * nfsstat(1m).
  38  */
  39 zone_key_t nfsstat_zone_key;
  40
  41 /*
  42  * Convenience routine to create a named kstat associated with zoneid, named
  43  * module:0:name:"misc", using the provided template to initialize the names
  44  * and values of the stats.
  45  */
  46 static kstat_named_t *
  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)
  50 {
  51         kstat_t *ksp;
  52         kstat_named_t *ks_data;
  53
  54         ks_data = kmem_alloc(template_size, KM_SLEEP);
  55         bcopy(template, ks_data, template_size);
  56         if ((ksp = kstat_create_zone(module, vers, name, "misc",
  57             KSTAT_TYPE_NAMED, template_size / sizeof (kstat_named_t),
  58             KSTAT_FLAG_VIRTUAL | KSTAT_FLAG_WRITABLE, zoneid)) != NULL) {
  59                 ksp->ks_data = ks_data;
  60                 kstat_install(ksp);
  61         }
  62         return (ks_data);
  63 }
  64
  65 /*
  66  * Convenience routine to remove a kstat in specified zone with name
  67  * module:0:name.
  68  */
  69 static void
  70 nfsstat_zone_fini_common(zoneid_t zoneid, const char *module, int vers,
  71                             const char *name)
  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 },
 144         { "rename",     KSTAT_DATA_UINT64 },
 145         { "link",       KSTAT_DATA_UINT64 },
 146         { "symlink",    KSTAT_DATA_UINT64 },
 147         { "mkdir",      KSTAT_DATA_UINT64 },
 148         { "rmdir",      KSTAT_DATA_UINT64 },
 149         { "readdir",    KSTAT_DATA_UINT64 },
 150         { "statfs",     KSTAT_DATA_UINT64 }
 151 };
 152
 153 static void
 154 nfsstat_zone_init_rfsreq_v2(zoneid_t zoneid, struct nfs_version_stats *statsp)
 155 {
 156         statsp->rfsreqcnt_ptr = nfsstat_zone_init_common(zoneid, "nfs", 0,
 157             "rfsreqcnt_v2", rfsreqcnt_v2_tmpl, sizeof (rfsreqcnt_v2_tmpl));
 158 }
 159
 160 static void
 161 nfsstat_zone_fini_rfsreq_v2(zoneid_t zoneid, struct nfs_version_stats *statsp)
 162 {
 163         nfsstat_zone_fini_common(zoneid, "nfs", 0, "rfsreqcnt_v2");
 164         kmem_free(statsp->rfsreqcnt_ptr, sizeof (rfsreqcnt_v2_tmpl));
 165 }
 166
 167 /*
 168  * NFSv2 server stats
 169  */
 170 static const kstat_named_t rfsproccnt_v2_tmpl[] = {
 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 },
 296         { "readdir",    KSTAT_DATA_UINT64 },
 297         { "readdirplus", KSTAT_DATA_UINT64 },
 298         { "fsstat",     KSTAT_DATA_UINT64 },
 299         { "fsinfo",     KSTAT_DATA_UINT64 },
 300         { "pathconf",   KSTAT_DATA_UINT64 },
 301         { "commit",     KSTAT_DATA_UINT64 }
 302 };
 303
 304 static void
 305 nfsstat_zone_init_rfsreq_v3(zoneid_t zoneid, struct nfs_version_stats *statsp)
 306 {
 307         statsp->rfsreqcnt_ptr = nfsstat_zone_init_common(zoneid, "nfs", 0,
 308             "rfsreqcnt_v3", rfsreqcnt_v3_tmpl, sizeof (rfsreqcnt_v3_tmpl));
 309 }
 310
 311 static void
 312 nfsstat_zone_fini_rfsreq_v3(zoneid_t zoneid, struct nfs_version_stats *statsp)
 313 {
 314         nfsstat_zone_fini_common(zoneid, "nfs", 0, "rfsreqcnt_v3");
 315         kmem_free(statsp->rfsreqcnt_ptr, sizeof (rfsreqcnt_v3_tmpl));
 316 }
 317
 318 /*
 319  * NFSv3 server stats
 320  */
 321 static const kstat_named_t rfsproccnt_v3_tmpl[] = {
 322         { "null",       KSTAT_DATA_UINT64 },
 323         { "getattr",    KSTAT_DATA_UINT64 },
 324         { "setattr",    KSTAT_DATA_UINT64 },
 325         { "lookup",     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 },
 447         { "lookupp",    KSTAT_DATA_UINT64 },
 448         { "nverify",    KSTAT_DATA_UINT64 },
 449         { "open",       KSTAT_DATA_UINT64 },
 450         { "openattr",   KSTAT_DATA_UINT64 },
 451         { "open_confirm",       KSTAT_DATA_UINT64 },
 452         { "open_downgrade",     KSTAT_DATA_UINT64 },
 453         { "putfh",      KSTAT_DATA_UINT64 },
 454         { "putpubfh",   KSTAT_DATA_UINT64 },
 455         { "putrootfh",  KSTAT_DATA_UINT64 },
 456         { "read",       KSTAT_DATA_UINT64 },
 457         { "readdir",    KSTAT_DATA_UINT64 },
 458         { "readlink",   KSTAT_DATA_UINT64 },
 459         { "remove",     KSTAT_DATA_UINT64 },
 460         { "rename",     KSTAT_DATA_UINT64 },
 461         { "renew",      KSTAT_DATA_UINT64 },
 462         { "restorefh",  KSTAT_DATA_UINT64 },
 463         { "savefh",     KSTAT_DATA_UINT64 },
 464         { "secinfo",    KSTAT_DATA_UINT64 },
 465         { "setattr",    KSTAT_DATA_UINT64 },
 466         { "setclientid",        KSTAT_DATA_UINT64 },
 467         { "setclientid_confirm",        KSTAT_DATA_UINT64 },
 468         { "verify", KSTAT_DATA_UINT64 },
 469         { "write",      KSTAT_DATA_UINT64 }
 470 };
 471
 472 static void
 473 nfsstat_zone_init_rfsreq_v4(zoneid_t zoneid, struct nfs_version_stats *statsp)
 474 {
 475         statsp->rfsreqcnt_ptr = nfsstat_zone_init_common(zoneid, "nfs", 0,
 476             "rfsreqcnt_v4", rfsreqcnt_v4_tmpl, sizeof (rfsreqcnt_v4_tmpl));
 477 }
 478
 479 static void
 480 nfsstat_zone_fini_rfsreq_v4(zoneid_t zoneid, struct nfs_version_stats *statsp)
 481 {
 482         nfsstat_zone_fini_common(zoneid, "nfs", 0, "rfsreqcnt_v4");
 483         kmem_free(statsp->rfsreqcnt_ptr, sizeof (rfsreqcnt_v4_tmpl));
 484 }
 485
 486 /*
 487  * NFSv4 server stats
 488  */
 489 static const kstat_named_t rfsproccnt_v4_tmpl[] = {
 490         { "null",       KSTAT_DATA_UINT64 },
 491         { "compound",   KSTAT_DATA_UINT64 },
 492         { "reserved",   KSTAT_DATA_UINT64 },
 493         { "access",     KSTAT_DATA_UINT64 },
 494         { "close",      KSTAT_DATA_UINT64 },
 495         { "commit",     KSTAT_DATA_UINT64 },
 496         { "create",     KSTAT_DATA_UINT64 },
 497         { "delegpurge", KSTAT_DATA_UINT64 },
 498         { "delegreturn",        KSTAT_DATA_UINT64 },
 499         { "getattr",    KSTAT_DATA_UINT64 },
 500         { "getfh",      KSTAT_DATA_UINT64 },
 501         { "link",       KSTAT_DATA_UINT64 },
 502         { "lock",       KSTAT_DATA_UINT64 },
 503         { "lockt",      KSTAT_DATA_UINT64 },
 504         { "locku",      KSTAT_DATA_UINT64 },
 505         { "lookup",     KSTAT_DATA_UINT64 },
 506         { "lookupp",    KSTAT_DATA_UINT64 },
 507         { "nverify",    KSTAT_DATA_UINT64 },
 508         { "open",       KSTAT_DATA_UINT64 },
 509         { "openattr",   KSTAT_DATA_UINT64 },
 510         { "open_confirm",       KSTAT_DATA_UINT64 },
 511         { "open_downgrade",     KSTAT_DATA_UINT64 },
 512         { "putfh",      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 }