Lines Matching refs:ctl
729 fd = contract_open(ctid, "all", "ctl", O_WRONLY);
811 zsd_lookup_zone(zsd_ctl_t *ctl, char *zonename, zoneid_t zoneid)
815 for (zone = list_head(&ctl->zsctl_zones); zone != NULL;
816 zone = list_next(&ctl->zsctl_zones, zone)) {
827 zsd_lookup_zone_byid(zsd_ctl_t *ctl, zoneid_t zoneid)
831 for (zone = list_head(&ctl->zsctl_zones); zone != NULL;
832 zone = list_next(&ctl->zsctl_zones, zone)) {
840 zsd_allocate_zone(zsd_ctl_t *ctl, char *zonename, zoneid_t zoneid)
874 ctl->zsctl_nzones++;
880 zsd_lookup_insert_zone(zsd_ctl_t *ctl, char *zonename, zoneid_t zoneid)
884 if ((zone = zsd_lookup_zone(ctl, zonename, zoneid)) != NULL)
887 if ((zone = zsd_allocate_zone(ctl, zonename, zoneid)) == NULL)
891 tmp = list_head(&ctl->zsctl_zones);
893 tmp = list_next(&ctl->zsctl_zones, tmp);
895 list_insert_before(&ctl->zsctl_zones, tmp, zone);
905 zsd_mark_zones_start(zsd_ctl_t *ctl)
910 for (zone = list_head(&ctl->zsctl_zones); zone != NULL;
911 zone = list_next(&ctl->zsctl_zones, zone)) {
941 zsd_mark_psets_start(zsd_ctl_t *ctl)
945 for (pset = list_head(&ctl->zsctl_psets); pset != NULL;
946 pset = list_next(&ctl->zsctl_psets, pset)) {
1037 zsd_add_usage(zsd_ctl_t *ctl, zsd_pset_usage_t *usage, timestruc_t *delta)
1039 zsd_system_t *system = ctl->zsctl_system;
1051 zsd_mark_psets_end(zsd_ctl_t *ctl)
1059 pset = list_head(&ctl->zsctl_psets);
1065 pset = list_next(&ctl->zsctl_psets, pset);
1066 list_remove(&ctl->zsctl_psets, tmp);
1068 ctl->zsctl_npsets--;
1077 pset = list_next(&ctl->zsctl_psets, pset);
1083 zsd_mark_pset_usages_end(zsd_ctl_t *ctl)
1093 for (pset = list_head(&ctl->zsctl_psets); pset != NULL;
1094 pset = list_next(&ctl->zsctl_psets, pset)) {
1110 ctl->zsctl_npset_usages--;
1134 zsd_mark_zone_found(zsd_ctl_t *ctl, zsd_zone_t *zone, uint64_t cpu_shares,
1143 zsd_system_t *sys = ctl->zsctl_system;
1210 zsd_mark_zones_end(zsd_ctl_t *ctl)
1218 zone = list_head(&ctl->zsctl_zones);
1228 zone = list_next(&ctl->zsctl_zones, zone);
1229 list_remove(&ctl->zsctl_zones, tmp);
1231 ctl->zsctl_nzones--;
1239 zone = list_next(&ctl->zsctl_zones, zone);
1252 zsd_mark_cpus_start(zsd_ctl_t *ctl, boolean_t roll)
1260 for (cpu = list_head(&ctl->zsctl_cpus); cpu != NULL;
1261 cpu = list_next(&ctl->zsctl_cpus, cpu)) {
1278 zsd_lookup_insert_cpu(zsd_ctl_t *ctl, processorid_t cpuid)
1282 assert(cpuid < ctl->zsctl_maxcpuid);
1283 cpu = &(ctl->zsctl_cpu_array[cpuid]);
1288 list_insert_tail(&ctl->zsctl_cpus, cpu);
1333 zsd_mark_cpus_end(zsd_ctl_t *ctl)
1339 cpu = list_head(&ctl->zsctl_cpus);
1347 cpu = list_next(&ctl->zsctl_cpus, cpu);
1348 list_remove(&ctl->zsctl_cpus, tmp);
1370 cpu = list_next(&ctl->zsctl_cpus, cpu);
1376 zsd_lookup_pset_byid(zsd_ctl_t *ctl, psetid_t psetid)
1380 for (pset = list_head(&ctl->zsctl_psets); pset != NULL;
1381 pset = list_next(&ctl->zsctl_psets, pset)) {
1389 zsd_lookup_pset(zsd_ctl_t *ctl, char *psetname, psetid_t psetid)
1393 for (pset = list_head(&ctl->zsctl_psets); pset != NULL;
1394 pset = list_next(&ctl->zsctl_psets, pset)) {
1405 zsd_allocate_pset(zsd_ctl_t *ctl, char *psetname, psetid_t psetid)
1426 ctl->zsctl_npsets++;
1432 zsd_lookup_insert_pset(zsd_ctl_t *ctl, char *psetname, psetid_t psetid)
1436 if ((pset = zsd_lookup_pset(ctl, psetname, psetid)) != NULL)
1439 if ((pset = zsd_allocate_pset(ctl, psetname, psetid)) == NULL)
1443 tmp = list_head(&ctl->zsctl_psets);
1445 tmp = list_next(&ctl->zsctl_psets, tmp);
1447 list_insert_before(&ctl->zsctl_psets, tmp, pset);
1466 zsd_allocate_pset_usage(zsd_ctl_t *ctl, zsd_pset_t *pset, zsd_zone_t *zone)
1493 ctl->zsctl_npset_usages++;
1500 zsd_lookup_insert_usage(zsd_ctl_t *ctl, zsd_pset_t *pset, zsd_zone_t *zone)
1508 if ((usage = zsd_allocate_pset_usage(ctl, pset, zone)) == NULL)
1521 zsd_refresh_system(zsd_ctl_t *ctl)
1523 zsd_system_t *system = ctl->zsctl_system;
1538 zsd_update_cpu_stats(zsd_ctl_t *ctl, zsd_cpu_t *cpu)
1549 sys = ctl->zsctl_system;
1556 kstat = kstat_lookup(ctl->zsctl_kstat_ctl, "cpu", cpuid, "sys");
1560 kid = kstat_read(ctl->zsctl_kstat_ctl, kstat, NULL);
1634 (pset_prev = zsd_lookup_pset_byid(ctl,
1667 zsd_get_pool_pset(zsd_ctl_t *ctl, psetid_t psetid, char *psetname,
1673 pool_conf_t *conf = ctl->zsctl_pool_conf;
1674 pool_value_t **vals = ctl->zsctl_pool_vals;
1684 if (ctl->zsctl_pool_status == POOL_DISABLED) {
1690 old = num = ctl->zsctl_cpu_ncache;
1692 ctl->zsctl_cpu_cache);
1703 ctl->zsctl_cpu_cache, num *
1705 ctl->zsctl_cpu_ncache = num;
1706 ctl->zsctl_cpu_cache = cache;
1818 if (num > ctl->zsctl_cpu_ncache) {
1820 ctl->zsctl_cpu_cache, num *
1822 ctl->zsctl_cpu_ncache = num;
1823 ctl->zsctl_cpu_cache = cache;
1851 ctl->zsctl_cpu_cache[i] = (psetid_t)int64;
1874 zsd_refresh_psets(zsd_ctl_t *ctl)
1895 system = ctl->zsctl_system;
1902 conf = ctl->zsctl_pool_conf;
1903 vals = ctl->zsctl_pool_vals;
1907 if (ctl->zsctl_pool_status == POOL_DISABLED) {
1908 if (pool_conf_open(ctl->zsctl_pool_conf,
1910 ctl->zsctl_pool_status = POOL_ENABLED;
1911 ctl->zsctl_pool_changed = POU_PSET;
1914 ctl->zsctl_pool_changed = 0;
1915 ret = pool_conf_update(ctl->zsctl_pool_conf,
1916 &(ctl->zsctl_pool_changed));
1919 (void) pool_conf_close(ctl->zsctl_pool_conf);
1920 ctl->zsctl_pool_status = POOL_DISABLED;
1941 if (num > ctl->zsctl_pset_ncache) {
1942 if ((cache = (psetid_t *)realloc(ctl->zsctl_pset_cache,
1946 ctl->zsctl_pset_ncache = num;
1947 ctl->zsctl_pset_cache = cache;
1957 ctl->zsctl_pset_cache[i] = (int)sys_id;
1962 if (ctl->zsctl_pool_status == POOL_ENABLED) {
1963 (void) pool_conf_close(ctl->zsctl_pool_conf);
1964 ctl->zsctl_pool_status = POOL_DISABLED;
1968 old = num = ctl->zsctl_pset_ncache;
1969 (void) pset_list(ctl->zsctl_pset_cache, &num);
1973 if ((cache = (psetid_t *)realloc(ctl->zsctl_pset_cache,
1975 ctl->zsctl_pset_ncache = num + 1;
1976 ctl->zsctl_pset_cache = cache;
1986 ctl->zsctl_pset_cache[num] = ctl->zsctl_pset_cache[0];
1987 ctl->zsctl_pset_cache[0] = ZS_PSET_DEFAULT;
1991 zsd_mark_cpus_start(ctl, roll_cpus);
1992 zsd_mark_psets_start(ctl);
1999 sys_id = ctl->zsctl_pset_cache[i];
2000 if (zsd_get_pool_pset(ctl, sys_id, psetname, sizeof (psetname),
2013 pset = zsd_lookup_insert_pset(ctl, psetname,
2014 ctl->zsctl_pset_cache[i]);
2022 cpuid = ctl->zsctl_cpu_cache[j];
2023 cpu = zsd_lookup_insert_cpu(ctl, cpuid);
2040 zsd_get_zone_pool_pset(zsd_ctl_t *ctl, zsd_zone_t *zone,
2048 pool_conf_t *conf = ctl->zsctl_pool_conf;
2050 pool_value_t **vals = ctl->zsctl_pool_vals;
2072 if (ctl->zsctl_pool_status == POOL_DISABLED)
2201 zsd_get_zone_caps(zsd_ctl_t *ctl, zsd_zone_t *zone, uint64_t *cpu_shares,
2213 zsd_system_t *sys = ctl->zsctl_system;
2376 zsd_refresh_zones(zsd_ctl_t *ctl)
2412 old = num = ctl->zsctl_zone_ncache;
2413 (void) zone_list(ctl->zsctl_zone_cache, &num);
2416 if ((cache = (zoneid_t *)realloc(ctl->zsctl_zone_cache,
2418 ctl->zsctl_zone_ncache = num;
2419 ctl->zsctl_zone_cache = cache;
2426 zsd_mark_zones_start(ctl);
2430 ret = getzonenamebyid(ctl->zsctl_zone_cache[i],
2435 zone = zsd_lookup_insert_zone(ctl, zonename,
2436 ctl->zsctl_zone_cache[i]);
2438 ret = zone_getattr(ctl->zsctl_zone_cache[i], ZONE_ATTR_FLAGS,
2448 zsd_get_zone_pool_pset(ctl, zone, poolname, sizeof (poolname),
2451 if (zsd_get_zone_caps(ctl, zone, &cpu_shares, &cpu_cap,
2458 zsd_mark_zone_found(ctl, zone, cpu_shares, cpu_cap, ram_cap,
2468 zsd_get_proc_info(zsd_ctl_t *ctl, psinfo_t *psinfo, psetid_t *psetid,
2476 proc = &(ctl->zsctl_proc_array[psinfo->pr_pid]);
2523 zsd_open_exacct(zsd_ctl_t *ctl, boolean_t init)
2537 fd = &ctl->zsctl_proc_fd;
2538 eaf = &ctl->zsctl_proc_eaf;
2539 stat = &ctl->zsctl_proc_stat;
2540 open = &ctl->zsctl_proc_open;
2543 fd = &ctl->zsctl_proc_fd_next;
2544 eaf = &ctl->zsctl_proc_eaf_next;
2545 stat = &ctl->zsctl_proc_stat_next;
2546 open = &ctl->zsctl_proc_open_next;
2618 zsd_refresh_procs(zsd_ctl_t *ctl, boolean_t init)
2646 ret = zsd_open_exacct(ctl, init);
2664 dent = ctl->zsctl_procfs_dent;
2666 (void) memset(dent, 0, ctl->zsctl_procfs_dent_size);
2688 zsd_get_proc_info(ctl, &psinfo, &psetid, &prev_psetid,
2697 zone = zsd_lookup_zone_byid(ctl, zoneid);
2700 pset = zsd_lookup_pset_byid(ctl, psetid);
2703 usage = zsd_lookup_insert_usage(ctl, pset, zone);
2712 prev_zone = zsd_lookup_zone_byid(ctl, prev_zoneid);
2717 prev_pset = zsd_lookup_pset_byid(ctl, prev_psetid);
2728 prev_usage = zsd_lookup_insert_usage(ctl, prev_pset,
2748 zsd_add_usage(ctl, usage, &delta);
2750 zsd_add_usage(ctl, usage, &d1);
2751 zsd_add_usage(ctl, prev_usage, &d2);
2785 ret = ea_get_object(&ctl->zsctl_proc_eaf, &object);
2796 stat = &(ctl->zsctl_proc_stat);
2797 stat_next = &(ctl->zsctl_proc_stat_next);
2805 ea_clear(&ctl->zsctl_proc_eaf);
2812 (void) ea_close(&ctl->zsctl_proc_eaf);
2814 ctl->zsctl_proc_fd =
2815 ctl->zsctl_proc_fd_next;
2816 ctl->zsctl_proc_eaf =
2817 ctl->zsctl_proc_eaf_next;
2818 ctl->zsctl_proc_stat =
2819 ctl->zsctl_proc_stat_next;
2821 ctl->zsctl_proc_fd_next = -1;
2822 ctl->zsctl_proc_open_next = 0;
2843 ret = ea_get_object(&ctl->zsctl_proc_eaf,
2863 proc = &(ctl->zsctl_proc_array[pid]);
2873 pproc = &(ctl->zsctl_proc_array[ppid]);
2877 zone = zsd_lookup_zone(ctl,
2959 pset = zsd_lookup_pset_byid(ctl, prev_psetid);
2964 pset = zsd_lookup_pset_byid(ctl, prev_psetid);
2983 usage = zsd_lookup_insert_usage(ctl, pset, zone);
2995 zsd_add_usage(ctl, usage, &delta);
3005 if (ctl->zsctl_proc_open_next) {
3007 &ctl->zsctl_proc_eaf_next);
3008 ctl->zsctl_proc_open_next = 0;
3009 ctl->zsctl_proc_fd_next = -1;
3027 pproc = &(ctl->zsctl_proc_array[next->zspr_ppid]);
3049 zone = zsd_lookup_zone_byid(ctl,
3058 pset = zsd_lookup_pset_byid(ctl,
3068 usage = zsd_lookup_insert_usage(ctl, pset, zone);
3077 zsd_add_usage(ctl, usage, &proc->zspr_usage);
3093 zone = zsd_lookup_zone_byid(ctl, proc->zspr_zoneid);
3099 pset = zsd_lookup_pset_byid(ctl, prev_psetid);
3101 pset = zsd_lookup_pset(ctl, zone->zsz_pset, -1);
3124 usage = zsd_lookup_insert_usage(ctl, pset, zone);
3129 zsd_add_usage(ctl, usage, &proc->zspr_usage);
3142 if (ctl->zsctl_proc_open_next) {
3143 (void) ea_close(&ctl->zsctl_proc_eaf_next);
3144 ctl->zsctl_proc_open_next = 0;
3145 ctl->zsctl_proc_fd_next = -1;
3156 zsd_getvmusage(zsd_ctl_t *ctl, uint_t flags, time_t age, zsd_vmusage64_t *buf,
3165 if (ctl->zsctl_kern_bits == 32) {
3211 zsd_refresh_memory(zsd_ctl_t *ctl, boolean_t init)
3255 sys = ctl->zsctl_system;
3268 if (num_swap_devices > ctl->zsctl_swap_cache_num) {
3272 if (ctl->zsctl_swap_cache != NULL)
3273 free(ctl->zsctl_swap_cache);
3296 ctl->zsctl_swap_cache = swt;
3297 ctl->zsctl_swap_cache_size = swt_size;
3298 ctl->zsctl_swap_cache_num = num_swap_devices;
3300 num_swap_devices = swapctl(SC_LIST, ctl->zsctl_swap_cache);
3316 swent = ctl->zsctl_swap_cache->swt_ent;
3321 disk_swap_total *= ctl->zsctl_pagesize;
3322 disk_swap_used *= ctl->zsctl_pagesize;
3331 kstat = kstat_lookup(ctl->zsctl_kstat_ctl, "unix", 0, "system_pages");
3335 kid = kstat_read(ctl->zsctl_kstat_ctl, kstat, NULL);
3364 physmem *= ctl->zsctl_pagesize;
3365 pp_kernel *= ctl->zsctl_pagesize;
3370 kstat = kstat_lookup(ctl->zsctl_kstat_ctl, "zfs", 0, "arcstats");
3372 kid = kstat_read(ctl->zsctl_kstat_ctl, kstat, NULL);
3388 vmusage = ctl->zsctl_vmusage_cache;
3389 num_vmusage = ctl->zsctl_vmusage_cache_num;
3391 ret = zsd_getvmusage(ctl, VMUSAGE_SYSTEM | VMUSAGE_ALL_ZONES, 0,
3404 if (num_vmusage > ctl->zsctl_vmusage_cache_num) {
3408 if (ctl->zsctl_vmusage_cache != NULL)
3409 free(ctl->zsctl_vmusage_cache);
3417 ctl->zsctl_vmusage_cache = vmusage;
3418 ctl->zsctl_vmusage_cache_num = num_vmusage;
3434 zone = zsd_lookup_zone_byid(ctl, vmusage[i].vmu_id);
3455 for (zone = list_head(&ctl->zsctl_zones); zone != NULL;
3456 zone = list_next(&ctl->zsctl_zones, zone)) {
3480 kstat = kstat_lookup(ctl->zsctl_kstat_ctl, "caps",
3483 kid = kstat_read(ctl->zsctl_kstat_ctl, kstat, NULL);
3500 kstat = kstat_lookup(ctl->zsctl_kstat_ctl, "caps",
3503 kid = kstat_read(ctl->zsctl_kstat_ctl, kstat, NULL);
3525 sysconf(_SC_PHYS_PAGES) * ctl->zsctl_pagesize;
3528 * ctl->zsctl_pagesize;
3550 vm_free = (ani.ani_max - ani.ani_resv) * ctl->zsctl_pagesize;
3561 zsd_refresh_cpu_stats(zsd_ctl_t *ctl, boolean_t init)
3574 cpu_next = list_head(&ctl->zsctl_cpus);
3577 cpu_next = list_next(&ctl->zsctl_cpus, cpu);
3578 zsd_update_cpu_stats(ctl, cpu);
3584 ctl->zsctl_hrtime = hrtime;
3585 ctl->zsctl_hrtime_prev = hrtime;
3589 ctl->zsctl_hrtime_prev = ctl->zsctl_hrtime;
3590 ctl->zsctl_hrtime = hrtime;
3591 if ((hrtime = hrtime - ctl->zsctl_hrtime_prev) > 0)
3592 TIMESTRUC_ADD_NANOSEC(ctl->zsctl_hrtime_total, hrtime);
3599 for (pset = list_head(&ctl->zsctl_psets); pset != NULL;
3600 pset = list_next(&ctl->zsctl_psets, pset)) {
3653 for (zone = list_head(&ctl->zsctl_zones); zone != NULL;
3654 zone = list_next(&ctl->zsctl_zones, zone)) {
3660 elapsed = ctl->zsctl_hrtime - ctl->zsctl_hrtime_prev;
3666 sys = ctl->zsctl_system;
3695 zsd_usage_cache_update(zsd_ctl_t *ctl)
3717 sizeof (zs_zone_t) * ctl->zsctl_nzones +
3718 sizeof (zs_pset_t) * ctl->zsctl_npsets +
3719 sizeof (zs_pset_zone_t) * ctl->zsctl_npset_usages;
3738 usage->zsu_nzones = ctl->zsctl_nzones;
3739 usage->zsu_npsets = ctl->zsctl_npsets;
3745 dsys = ctl->zsctl_system;
3779 for (i = 0, dzone = list_head(&ctl->zsctl_zones);
3780 i < ctl->zsctl_nzones;
3781 i++, dzone = list_next(&ctl->zsctl_zones, dzone)) {
3831 for (i = 0, dpset = list_head(&ctl->zsctl_psets);
3832 i < ctl->zsctl_npsets;
3833 i++, dpset = list_next(&ctl->zsctl_psets, dpset)) {
3919 zsd_close(zsd_ctl_t *ctl)
3927 if (ctl->zsctl_kstat_ctl) {
3928 (void) kstat_close(ctl->zsctl_kstat_ctl);
3929 ctl->zsctl_kstat_ctl = NULL;
3931 if (ctl->zsctl_proc_open) {
3932 (void) ea_close(&ctl->zsctl_proc_eaf);
3933 ctl->zsctl_proc_open = 0;
3934 ctl->zsctl_proc_fd = -1;
3936 if (ctl->zsctl_pool_conf) {
3937 if (ctl->zsctl_pool_status == POOL_ENABLED)
3938 (void) pool_conf_close(ctl->zsctl_pool_conf);
3939 ctl->zsctl_pool_status = POOL_DISABLED;
3942 while ((zone = list_head(&ctl->zsctl_zones)) != NULL) {
3943 list_remove(&ctl->zsctl_zones, zone);
3945 ctl->zsctl_nzones--;
3948 while ((pset = list_head(&ctl->zsctl_psets)) != NULL) {
3952 ctl->zsctl_npset_usages--;
3955 list_remove(&ctl->zsctl_psets, pset);
3957 ctl->zsctl_npsets--;
3961 while (cpu = list_head(&ctl->zsctl_cpus)) {
3962 list_remove(&ctl->zsctl_cpus, cpu);
3971 assert(ctl->zsctl_npset_usages == 0);
3972 assert(ctl->zsctl_npsets == 0);
3973 assert(ctl->zsctl_nzones == 0);
3982 zsd_read(zsd_ctl_t *ctl, boolean_t init, boolean_t do_memory)
3984 (void) kstat_chain_update(ctl->zsctl_kstat_ctl);
3985 (void) gettimeofday(&(ctl->zsctl_timeofday), NULL);
3987 zsd_refresh_system(ctl);
3994 zsd_refresh_memory(ctl, init);
3995 zsd_refresh_zones(ctl);
3996 zsd_refresh_psets(ctl);
3997 zsd_refresh_procs(ctl, init);
3998 zsd_refresh_cpu_stats(ctl, init);
4005 zsd_mark_pset_usages_end(ctl);
4006 zsd_mark_psets_end(ctl);
4007 zsd_mark_cpus_end(ctl);
4008 zsd_mark_zones_end(ctl);
4013 zsd_usage_cache_update(ctl);
4051 zsd_open(zsd_ctl_t *ctl)
4063 if (ctl == NULL && (ctl = (zsd_ctl_t *)calloc(1,
4069 ctl->zsctl_proc_fd = -1;
4072 if (ctl->zsctl_kstat_ctl == NULL &&
4073 (ctl->zsctl_kstat_ctl = kstat_open()) == NULL) {
4086 ctl->zsctl_proc_fd = -1;
4087 ctl->zsctl_proc_fd_next = -1;
4088 ctl->zsctl_proc_open = 0;
4089 ctl->zsctl_proc_open_next = 0;
4095 if (ctl->zsctl_system == NULL && (ctl->zsctl_system = (zsd_system_t *)
4102 system = ctl->zsctl_system;
4106 ctl->zsctl_kern_bits = 32;
4108 ctl->zsctl_kern_bits = 64;
4109 ctl->zsctl_pagesize = sysconf(_SC_PAGESIZE);
4112 ctl->zsctl_maxcpuid = size;
4113 if (ctl->zsctl_cpu_array == NULL && (ctl->zsctl_cpu_array =
4119 for (i = 0; i <= ctl->zsctl_maxcpuid; i++) {
4120 ctl->zsctl_cpu_array[i].zsc_id = i;
4121 ctl->zsctl_cpu_array[i].zsc_allocated = B_FALSE;
4122 ctl->zsctl_cpu_array[i].zsc_psetid = ZS_PSET_ERROR;
4123 ctl->zsctl_cpu_array[i].zsc_psetid_prev = ZS_PSET_ERROR;
4133 ctl->zsctl_maxproc = size;
4134 if (ctl->zsctl_proc_array == NULL &&
4135 (ctl->zsctl_proc_array = (zsd_proc_t *)calloc(size,
4141 for (i = 0; i <= ctl->zsctl_maxproc; i++) {
4142 list_link_init(&(ctl->zsctl_proc_array[i].zspr_next));
4143 ctl->zsctl_proc_array[i].zspr_psetid = ZS_PSET_ERROR;
4144 ctl->zsctl_proc_array[i].zspr_zoneid = -1;
4145 ctl->zsctl_proc_array[i].zspr_usage.tv_sec = 0;
4146 ctl->zsctl_proc_array[i].zspr_usage.tv_nsec = 0;
4147 ctl->zsctl_proc_array[i].zspr_ppid = -1;
4150 list_create(&ctl->zsctl_zones, sizeof (zsd_zone_t),
4153 list_create(&ctl->zsctl_psets, sizeof (zsd_pset_t),
4156 list_create(&ctl->zsctl_cpus, sizeof (zsd_cpu_t),
4167 ctl->zsctl_procfs_dent_size = size;
4168 if (ctl->zsctl_procfs_dent == NULL &&
4169 (ctl->zsctl_procfs_dent = (struct dirent *)calloc(1, size))
4176 if (ctl->zsctl_pool_conf == NULL &&
4177 (ctl->zsctl_pool_conf = pool_conf_alloc()) == NULL) {
4182 ctl->zsctl_pool_status = POOL_DISABLED;
4183 ctl->zsctl_pool_changed = 0;
4185 if (ctl->zsctl_pool_vals[0] == NULL &&
4186 (ctl->zsctl_pool_vals[0] = pool_value_alloc()) == NULL) {
4191 if (ctl->zsctl_pool_vals[1] == NULL &&
4192 (ctl->zsctl_pool_vals[1] = pool_value_alloc()) == NULL) {
4197 ctl->zsctl_pool_vals[2] = NULL;
4213 if (zsd_read(ctl, B_TRUE, B_FALSE) != 0)
4216 return (ctl);
4218 if (ctl)
4219 zsd_close(ctl);