solaris-kstat 1.0.1 → 1.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (8) hide show
  1. data/CHANGES +13 -0
  2. data/README +8 -17
  3. data/Rakefile +37 -43
  4. data/ext/solaris/rkstat.c +170 -148
  5. data/ext/solaris/rkstat.h +276 -288
  6. data/solaris-kstat.gemspec +24 -29
  7. data/test/test_solaris_kstat.rb +155 -149
  8. metadata +20 -10
data/ext/solaris/rkstat.h CHANGED
@@ -2,9 +2,9 @@
2
2
  extern "C" {
3
3
  #endif
4
4
 
5
- #define SOLARIS_KSTAT_VERSION "1.0.1"
5
+ #define SOLARIS_KSTAT_VERSION "1.0.2"
6
6
 
7
- /* Function prototypes */
7
+ // Function prototypes
8
8
  static VALUE map_named_data_type(kstat_t* ksp);
9
9
  static VALUE map_io_data_type(kstat_io_t* kio);
10
10
  static VALUE map_intr_data_type(kstat_t* ksp);
@@ -18,346 +18,334 @@ static VALUE map_raw_sysinfo(kstat_t* ksp);
18
18
  static VALUE map_raw_cpu_sysinfo(kstat_t* ksp);
19
19
  static VALUE map_raw_mntinfo(kstat_t* ksp);
20
20
 
21
- /* Structure wrapped as our Kstat class */
21
+ // Structure wrapped as our Kstat class
22
22
  struct kstruct{
23
- kstat_ctl_t* kc;
24
- kstat_t* ksp;
23
+ kstat_ctl_t* kc;
24
+ kstat_t* ksp;
25
25
  };
26
26
 
27
27
  typedef struct kstruct KstatStruct;
28
28
 
29
29
  static void ks_free(KstatStruct* p){
30
- if(p->kc){
31
- kstat_close(p->kc);
32
- }
33
- free(p);
30
+ if(p->kc)
31
+ kstat_close(p->kc);
32
+
33
+ free(p);
34
34
  }
35
35
 
36
- /* Helps reduce GC for String key/value pairs in a hash */
37
- void hash_add_pair(VALUE rbHash, const char *key, const char *value)
36
+ // Helps reduce GC for String key/value pairs in a hash
37
+ void hash_add_pair(VALUE v_hash, const char *key, const char *value)
38
38
  {
39
- volatile VALUE key_obj = rb_str_new2(key);
40
- rb_hash_aset(rbHash, key_obj, rb_str_new2(value));
39
+ volatile VALUE key_obj = rb_str_new2(key);
40
+ rb_hash_aset(v_hash, key_obj, rb_str_new2(value));
41
41
  }
42
42
 
43
- /* Helper functions */
43
+ // Helper functions
44
44
 
45
45
  static VALUE map_raw_mntinfo(kstat_t* ksp){
46
- struct mntinfo_kstat *mptr;
47
- mptr = (struct mntinfo_kstat*)(ksp->ks_data);
48
- volatile VALUE rbHash = rb_hash_new();
49
-
50
- rb_hash_aset(rbHash,rb_str_new2("mik_proto"),rb_str_new2(mptr->mik_proto));
51
- rb_hash_aset(rbHash,rb_str_new2("mik_vers"),UINT2NUM(mptr->mik_vers));
52
- rb_hash_aset(rbHash,rb_str_new2("mik_flags"),UINT2NUM(mptr->mik_flags));
53
- rb_hash_aset(rbHash,rb_str_new2("mik_secmod"),UINT2NUM(mptr->mik_secmod));
54
- rb_hash_aset(rbHash,rb_str_new2("mik_curread"),UINT2NUM(mptr->mik_curread));
55
- rb_hash_aset(rbHash,rb_str_new2("mik_curwrite"),
56
- UINT2NUM(mptr->mik_curwrite));
57
- rb_hash_aset(rbHash,rb_str_new2("mik_timeo"),UINT2NUM(mptr->mik_timeo));
58
- rb_hash_aset(rbHash,rb_str_new2("mik_retrans"),UINT2NUM(mptr->mik_retrans));
59
- rb_hash_aset(rbHash,rb_str_new2("mik_acregmin"),
60
- UINT2NUM(mptr->mik_acregmin));
61
- rb_hash_aset(rbHash,rb_str_new2("mik_acregmax"),
62
- UINT2NUM(mptr->mik_acregmax));
63
- rb_hash_aset(rbHash,rb_str_new2("mik_acdirmin"),
64
- UINT2NUM(mptr->mik_acdirmin));
65
- rb_hash_aset(rbHash,rb_str_new2("mik_acdirmax"),
66
- UINT2NUM(mptr->mik_acdirmax));
67
- rb_hash_aset(rbHash,rb_str_new2("mik_noresponse"),
68
- UINT2NUM(mptr->mik_noresponse));
69
- rb_hash_aset(rbHash,rb_str_new2("mik_failover"),
70
- UINT2NUM(mptr->mik_failover));
71
- rb_hash_aset(rbHash,rb_str_new2("mik_remap"), UINT2NUM(mptr->mik_remap));
72
- rb_hash_aset(rbHash,rb_str_new2("mik_curserver"),
73
- rb_str_new2(mptr->mik_curserver));
74
-
75
- return rbHash;
46
+ struct mntinfo_kstat *mptr;
47
+ mptr = (struct mntinfo_kstat*)(ksp->ks_data);
48
+ volatile VALUE v_hash = rb_hash_new();
49
+
50
+ rb_hash_aset(v_hash,rb_str_new2("mik_proto"),rb_str_new2(mptr->mik_proto));
51
+ rb_hash_aset(v_hash,rb_str_new2("mik_vers"),UINT2NUM(mptr->mik_vers));
52
+ rb_hash_aset(v_hash,rb_str_new2("mik_flags"),UINT2NUM(mptr->mik_flags));
53
+ rb_hash_aset(v_hash,rb_str_new2("mik_secmod"),UINT2NUM(mptr->mik_secmod));
54
+ rb_hash_aset(v_hash,rb_str_new2("mik_curread"),UINT2NUM(mptr->mik_curread));
55
+ rb_hash_aset(v_hash,rb_str_new2("mik_curwrite"), UINT2NUM(mptr->mik_curwrite));
56
+ rb_hash_aset(v_hash,rb_str_new2("mik_timeo"),UINT2NUM(mptr->mik_timeo));
57
+ rb_hash_aset(v_hash,rb_str_new2("mik_retrans"),UINT2NUM(mptr->mik_retrans));
58
+ rb_hash_aset(v_hash,rb_str_new2("mik_acregmin"), UINT2NUM(mptr->mik_acregmin));
59
+ rb_hash_aset(v_hash,rb_str_new2("mik_acregmax"), UINT2NUM(mptr->mik_acregmax));
60
+ rb_hash_aset(v_hash,rb_str_new2("mik_acdirmin"), UINT2NUM(mptr->mik_acdirmin));
61
+ rb_hash_aset(v_hash,rb_str_new2("mik_acdirmax"), UINT2NUM(mptr->mik_acdirmax));
62
+ rb_hash_aset(v_hash,rb_str_new2("mik_noresponse"), UINT2NUM(mptr->mik_noresponse));
63
+ rb_hash_aset(v_hash,rb_str_new2("mik_failover"), UINT2NUM(mptr->mik_failover));
64
+ rb_hash_aset(v_hash,rb_str_new2("mik_remap"), UINT2NUM(mptr->mik_remap));
65
+ rb_hash_aset(v_hash,rb_str_new2("mik_curserver"), rb_str_new2(mptr->mik_curserver));
66
+
67
+ return v_hash;
76
68
  }
77
69
 
78
70
  static VALUE map_raw_vminfo(kstat_t* ksp){
79
- vminfo_t *vminfop;
80
- vminfop = (vminfo_t *)ksp->ks_data;
81
- volatile VALUE rbHash = rb_hash_new();
71
+ vminfo_t *vminfop;
72
+ vminfop = (vminfo_t *)ksp->ks_data;
73
+ volatile VALUE v_hash = rb_hash_new();
82
74
 
83
- rb_hash_aset(rbHash,rb_str_new2("freemem"),ULL2NUM(vminfop->freemem));
84
- rb_hash_aset(rbHash,rb_str_new2("swap_resv"),ULL2NUM(vminfop->swap_resv));
85
- rb_hash_aset(rbHash,rb_str_new2("swap_alloc"),ULL2NUM(vminfop->swap_alloc));
86
- rb_hash_aset(rbHash,rb_str_new2("swap_avail"),ULL2NUM(vminfop->swap_avail));
87
- rb_hash_aset(rbHash,rb_str_new2("swap_free"),ULL2NUM(vminfop->swap_free));
75
+ rb_hash_aset(v_hash,rb_str_new2("freemem"),ULL2NUM(vminfop->freemem));
76
+ rb_hash_aset(v_hash,rb_str_new2("swap_resv"),ULL2NUM(vminfop->swap_resv));
77
+ rb_hash_aset(v_hash,rb_str_new2("swap_alloc"),ULL2NUM(vminfop->swap_alloc));
78
+ rb_hash_aset(v_hash,rb_str_new2("swap_avail"),ULL2NUM(vminfop->swap_avail));
79
+ rb_hash_aset(v_hash,rb_str_new2("swap_free"),ULL2NUM(vminfop->swap_free));
88
80
 
89
- return rbHash;
81
+ return v_hash;
90
82
  }
91
83
 
92
84
  static VALUE map_raw_var(kstat_t* ksp){
93
- struct var* v;
94
- v = (struct var *)ksp->ks_data;
95
- volatile VALUE rbHash = rb_hash_new();
96
-
97
- rb_hash_aset(rbHash,rb_str_new2("v_buf"),INT2NUM(v->v_buf));
98
- rb_hash_aset(rbHash,rb_str_new2("v_call"),INT2NUM(v->v_call));
99
- rb_hash_aset(rbHash,rb_str_new2("v_proc"),INT2NUM(v->v_proc));
100
- rb_hash_aset(rbHash,rb_str_new2("v_maxupttl"),INT2NUM(v->v_maxupttl));
101
- rb_hash_aset(rbHash,rb_str_new2("v_nglobpris"),INT2NUM(v->v_nglobpris));
102
- rb_hash_aset(rbHash,rb_str_new2("v_maxsyspri"),INT2NUM(v->v_maxsyspri));
103
- rb_hash_aset(rbHash,rb_str_new2("v_clist"),INT2NUM(v->v_clist));
104
- rb_hash_aset(rbHash,rb_str_new2("v_maxup"),INT2NUM(v->v_maxup));
105
- rb_hash_aset(rbHash,rb_str_new2("v_hbuf"),INT2NUM(v->v_hbuf));
106
- rb_hash_aset(rbHash,rb_str_new2("v_hmask"),INT2NUM(v->v_hmask));
107
- rb_hash_aset(rbHash,rb_str_new2("v_pbuf"),INT2NUM(v->v_pbuf));
108
- rb_hash_aset(rbHash,rb_str_new2("v_sptmap"),INT2NUM(v->v_sptmap));
109
- rb_hash_aset(rbHash,rb_str_new2("v_maxpmem"),INT2NUM(v->v_maxpmem));
110
- rb_hash_aset(rbHash,rb_str_new2("v_autoup"),INT2NUM(v->v_autoup));
111
- rb_hash_aset(rbHash,rb_str_new2("v_bufhwm"),INT2NUM(v->v_bufhwm));
112
-
113
- return rbHash;
85
+ struct var* v;
86
+ v = (struct var *)ksp->ks_data;
87
+ volatile VALUE v_hash = rb_hash_new();
88
+
89
+ rb_hash_aset(v_hash,rb_str_new2("v_buf"),INT2NUM(v->v_buf));
90
+ rb_hash_aset(v_hash,rb_str_new2("v_call"),INT2NUM(v->v_call));
91
+ rb_hash_aset(v_hash,rb_str_new2("v_proc"),INT2NUM(v->v_proc));
92
+ rb_hash_aset(v_hash,rb_str_new2("v_maxupttl"),INT2NUM(v->v_maxupttl));
93
+ rb_hash_aset(v_hash,rb_str_new2("v_nglobpris"),INT2NUM(v->v_nglobpris));
94
+ rb_hash_aset(v_hash,rb_str_new2("v_maxsyspri"),INT2NUM(v->v_maxsyspri));
95
+ rb_hash_aset(v_hash,rb_str_new2("v_clist"),INT2NUM(v->v_clist));
96
+ rb_hash_aset(v_hash,rb_str_new2("v_maxup"),INT2NUM(v->v_maxup));
97
+ rb_hash_aset(v_hash,rb_str_new2("v_hbuf"),INT2NUM(v->v_hbuf));
98
+ rb_hash_aset(v_hash,rb_str_new2("v_hmask"),INT2NUM(v->v_hmask));
99
+ rb_hash_aset(v_hash,rb_str_new2("v_pbuf"),INT2NUM(v->v_pbuf));
100
+ rb_hash_aset(v_hash,rb_str_new2("v_sptmap"),INT2NUM(v->v_sptmap));
101
+ rb_hash_aset(v_hash,rb_str_new2("v_maxpmem"),INT2NUM(v->v_maxpmem));
102
+ rb_hash_aset(v_hash,rb_str_new2("v_autoup"),INT2NUM(v->v_autoup));
103
+ rb_hash_aset(v_hash,rb_str_new2("v_bufhwm"),INT2NUM(v->v_bufhwm));
104
+
105
+ return v_hash;
114
106
  }
115
107
 
116
108
  static VALUE map_raw_flushmeter(kstat_t* ksp){
117
- struct flushmeter* fp;
118
- fp = (struct flushmeter *)ksp->ks_data;
119
- volatile VALUE rbHash = rb_hash_new();
120
-
121
- rb_hash_aset(rbHash,rb_str_new2("f_ctx"),ULL2NUM(fp->f_ctx));
122
- rb_hash_aset(rbHash,rb_str_new2("f_segment"),ULL2NUM(fp->f_segment));
123
- rb_hash_aset(rbHash,rb_str_new2("f_page"),ULL2NUM(fp->f_page));
124
- rb_hash_aset(rbHash,rb_str_new2("f_partial"),ULL2NUM(fp->f_partial));
125
- rb_hash_aset(rbHash,rb_str_new2("f_usr"),ULL2NUM(fp->f_usr));
126
- rb_hash_aset(rbHash,rb_str_new2("f_region"),ULL2NUM(fp->f_region));
127
-
128
- return rbHash;
109
+ struct flushmeter* fp;
110
+ fp = (struct flushmeter *)ksp->ks_data;
111
+ volatile VALUE v_hash = rb_hash_new();
112
+
113
+ rb_hash_aset(v_hash,rb_str_new2("f_ctx"),ULL2NUM(fp->f_ctx));
114
+ rb_hash_aset(v_hash,rb_str_new2("f_segment"),ULL2NUM(fp->f_segment));
115
+ rb_hash_aset(v_hash,rb_str_new2("f_page"),ULL2NUM(fp->f_page));
116
+ rb_hash_aset(v_hash,rb_str_new2("f_partial"),ULL2NUM(fp->f_partial));
117
+ rb_hash_aset(v_hash,rb_str_new2("f_usr"),ULL2NUM(fp->f_usr));
118
+ rb_hash_aset(v_hash,rb_str_new2("f_region"),ULL2NUM(fp->f_region));
119
+
120
+ return v_hash;
129
121
  }
130
122
 
131
123
  static VALUE map_raw_ncstats(kstat_t* ksp){
132
- struct ncstats* np;
133
- np = (struct ncstats *)ksp->ks_data;
134
- volatile VALUE rbHash = rb_hash_new();
135
-
136
- rb_hash_aset(rbHash,rb_str_new2("hits"),INT2NUM(np->hits));
137
- rb_hash_aset(rbHash,rb_str_new2("misses"),INT2NUM(np->misses));
138
- rb_hash_aset(rbHash,rb_str_new2("enters"),INT2NUM(np->enters));
139
- rb_hash_aset(rbHash,rb_str_new2("dbl_enters"),INT2NUM(np->dbl_enters));
140
- rb_hash_aset(rbHash,rb_str_new2("long_enter"),INT2NUM(np->long_enter));
141
- rb_hash_aset(rbHash,rb_str_new2("long_look"),INT2NUM(np->long_look));
142
- rb_hash_aset(rbHash,rb_str_new2("move_to_front"),INT2NUM(np->move_to_front));
143
- rb_hash_aset(rbHash,rb_str_new2("purges"),INT2NUM(np->purges));
144
-
145
- return rbHash;
124
+ struct ncstats* np;
125
+ np = (struct ncstats *)ksp->ks_data;
126
+ volatile VALUE v_hash = rb_hash_new();
127
+
128
+ rb_hash_aset(v_hash,rb_str_new2("hits"),INT2NUM(np->hits));
129
+ rb_hash_aset(v_hash,rb_str_new2("misses"),INT2NUM(np->misses));
130
+ rb_hash_aset(v_hash,rb_str_new2("enters"),INT2NUM(np->enters));
131
+ rb_hash_aset(v_hash,rb_str_new2("dbl_enters"),INT2NUM(np->dbl_enters));
132
+ rb_hash_aset(v_hash,rb_str_new2("long_enter"),INT2NUM(np->long_enter));
133
+ rb_hash_aset(v_hash,rb_str_new2("long_look"),INT2NUM(np->long_look));
134
+ rb_hash_aset(v_hash,rb_str_new2("move_to_front"),INT2NUM(np->move_to_front));
135
+ rb_hash_aset(v_hash,rb_str_new2("purges"),INT2NUM(np->purges));
136
+
137
+ return v_hash;
146
138
  }
147
139
 
148
140
  static VALUE map_raw_sysinfo(kstat_t* ksp){
149
- sysinfo_t* sp;
150
- sp = (sysinfo_t *)ksp->ks_data;
151
- volatile VALUE rbHash = rb_hash_new();
152
-
153
- rb_hash_aset(rbHash,rb_str_new2("updates"),UINT2NUM(sp->updates));
154
- rb_hash_aset(rbHash,rb_str_new2("runque"),UINT2NUM(sp->runque));
155
- rb_hash_aset(rbHash,rb_str_new2("runocc"),UINT2NUM(sp->runocc));
156
- rb_hash_aset(rbHash,rb_str_new2("swpque"),UINT2NUM(sp->swpque));
157
- rb_hash_aset(rbHash,rb_str_new2("swpocc"),UINT2NUM(sp->swpocc));
158
- rb_hash_aset(rbHash,rb_str_new2("waiting"),UINT2NUM(sp->waiting));
159
-
160
- return rbHash;
141
+ sysinfo_t* sp;
142
+ sp = (sysinfo_t *)ksp->ks_data;
143
+ volatile VALUE v_hash = rb_hash_new();
144
+
145
+ rb_hash_aset(v_hash,rb_str_new2("updates"),UINT2NUM(sp->updates));
146
+ rb_hash_aset(v_hash,rb_str_new2("runque"),UINT2NUM(sp->runque));
147
+ rb_hash_aset(v_hash,rb_str_new2("runocc"),UINT2NUM(sp->runocc));
148
+ rb_hash_aset(v_hash,rb_str_new2("swpque"),UINT2NUM(sp->swpque));
149
+ rb_hash_aset(v_hash,rb_str_new2("swpocc"),UINT2NUM(sp->swpocc));
150
+ rb_hash_aset(v_hash,rb_str_new2("waiting"),UINT2NUM(sp->waiting));
151
+
152
+ return v_hash;
161
153
  }
162
154
 
163
155
 
164
- /*
165
- * Maps the cpu_sysinfo struct from sys/sysinfo.h into a hash.
166
- */
156
+ // Maps the cpu_sysinfo struct from sys/sysinfo.h into a hash.
167
157
  static VALUE map_raw_cpu_sysinfo(kstat_t* ksp){
168
- cpu_sysinfo_t* cptr;
169
- cptr = (cpu_sysinfo_t *)ksp->ks_data;
170
- volatile VALUE rbHash = rb_hash_new();
171
-
172
- rb_hash_aset(rbHash,rb_str_new2("cpu_idle"),UINT2NUM(cptr->cpu[CPU_IDLE]));
173
- rb_hash_aset(rbHash,rb_str_new2("cpu_user"),UINT2NUM(cptr->cpu[CPU_USER]));
174
- rb_hash_aset(rbHash,rb_str_new2("cpu_kernel"),UINT2NUM(cptr->cpu[CPU_KERNEL]));
175
- rb_hash_aset(rbHash,rb_str_new2("cpu_wait"),UINT2NUM(cptr->cpu[CPU_WAIT]));
176
- rb_hash_aset(rbHash,rb_str_new2("wait_io"),UINT2NUM(cptr->wait[W_IO]));
177
- rb_hash_aset(rbHash,rb_str_new2("wait_swap"),UINT2NUM(cptr->wait[W_SWAP]));
178
- rb_hash_aset(rbHash,rb_str_new2("wait_pio"),UINT2NUM(cptr->wait[W_PIO]));
179
- rb_hash_aset(rbHash,rb_str_new2("bread"),UINT2NUM(cptr->bread));
180
- rb_hash_aset(rbHash,rb_str_new2("bwrite"),UINT2NUM(cptr->bwrite));
181
- rb_hash_aset(rbHash,rb_str_new2("lread"),UINT2NUM(cptr->lread));
182
- rb_hash_aset(rbHash,rb_str_new2("lwrite"),UINT2NUM(cptr->lwrite));
183
- rb_hash_aset(rbHash,rb_str_new2("phread"),UINT2NUM(cptr->phread));
184
- rb_hash_aset(rbHash,rb_str_new2("phwrite"),UINT2NUM(cptr->phwrite));
185
- rb_hash_aset(rbHash,rb_str_new2("pswitch"),UINT2NUM(cptr->pswitch));
186
- rb_hash_aset(rbHash,rb_str_new2("trap"),UINT2NUM(cptr->trap));
187
- rb_hash_aset(rbHash,rb_str_new2("intr"),UINT2NUM(cptr->intr));
188
- rb_hash_aset(rbHash,rb_str_new2("syscall"),UINT2NUM(cptr->syscall));
189
- rb_hash_aset(rbHash,rb_str_new2("sysread"),UINT2NUM(cptr->sysread));
190
- rb_hash_aset(rbHash,rb_str_new2("syswrite"),UINT2NUM(cptr->syswrite));
191
- rb_hash_aset(rbHash,rb_str_new2("sysfork"),UINT2NUM(cptr->sysfork));
192
- rb_hash_aset(rbHash,rb_str_new2("sysvfork"),UINT2NUM(cptr->sysvfork));
193
- rb_hash_aset(rbHash,rb_str_new2("sysexec"),UINT2NUM(cptr->sysexec));
194
- rb_hash_aset(rbHash,rb_str_new2("readch"),UINT2NUM(cptr->readch));
195
- rb_hash_aset(rbHash,rb_str_new2("writech"),UINT2NUM(cptr->writech));
196
- rb_hash_aset(rbHash,rb_str_new2("rcvint"),UINT2NUM(cptr->rcvint));
197
- rb_hash_aset(rbHash,rb_str_new2("xmtint"),UINT2NUM(cptr->xmtint));
198
- rb_hash_aset(rbHash,rb_str_new2("mdmint"),UINT2NUM(cptr->mdmint));
199
- rb_hash_aset(rbHash,rb_str_new2("rawch"),UINT2NUM(cptr->rawch));
200
- rb_hash_aset(rbHash,rb_str_new2("canch"),UINT2NUM(cptr->canch));
201
- rb_hash_aset(rbHash,rb_str_new2("outch"),UINT2NUM(cptr->outch));
202
- rb_hash_aset(rbHash,rb_str_new2("msg"),UINT2NUM(cptr->msg));
203
- rb_hash_aset(rbHash,rb_str_new2("sema"),UINT2NUM(cptr->sema));
204
- rb_hash_aset(rbHash,rb_str_new2("namei"),UINT2NUM(cptr->namei));
205
- rb_hash_aset(rbHash,rb_str_new2("ufsiget"),UINT2NUM(cptr->ufsiget));
206
- rb_hash_aset(rbHash,rb_str_new2("ufsdirblk"),UINT2NUM(cptr->ufsdirblk));
207
- rb_hash_aset(rbHash,rb_str_new2("ufsipage"),UINT2NUM(cptr->ufsipage));
208
- rb_hash_aset(rbHash,rb_str_new2("ufsinopage"),UINT2NUM(cptr->ufsinopage));
209
- rb_hash_aset(rbHash,rb_str_new2("inodeovf"),UINT2NUM(cptr->inodeovf));
210
- rb_hash_aset(rbHash,rb_str_new2("fileovf"),UINT2NUM(cptr->fileovf));
211
- rb_hash_aset(rbHash,rb_str_new2("procovf"),UINT2NUM(cptr->procovf));
212
- rb_hash_aset(rbHash,rb_str_new2("intrthread"),UINT2NUM(cptr->intrthread));
213
- rb_hash_aset(rbHash,rb_str_new2("intrblk"),UINT2NUM(cptr->intrblk));
214
- rb_hash_aset(rbHash,rb_str_new2("idlethread"),UINT2NUM(cptr->idlethread));
215
- rb_hash_aset(rbHash,rb_str_new2("inv_swtch"),UINT2NUM(cptr->inv_swtch));
216
- rb_hash_aset(rbHash,rb_str_new2("nthreads"),UINT2NUM(cptr->nthreads));
217
- rb_hash_aset(rbHash,rb_str_new2("cpumigrate"),UINT2NUM(cptr->cpumigrate));
218
- rb_hash_aset(rbHash,rb_str_new2("xcalls"),UINT2NUM(cptr->xcalls));
219
- rb_hash_aset(rbHash,rb_str_new2("mutex_adenters"),
220
- UINT2NUM(cptr->mutex_adenters));
221
- rb_hash_aset(rbHash,rb_str_new2("rw_rdfails"),UINT2NUM(cptr->rw_rdfails));
222
- rb_hash_aset(rbHash,rb_str_new2("rw_wrfails"),UINT2NUM(cptr->rw_wrfails));
223
- rb_hash_aset(rbHash,rb_str_new2("modload"),UINT2NUM(cptr->modload));
224
- rb_hash_aset(rbHash,rb_str_new2("modunload"),UINT2NUM(cptr->modunload));
225
- rb_hash_aset(rbHash,rb_str_new2("bawrite"),UINT2NUM(cptr->bawrite));
158
+ cpu_sysinfo_t* cptr;
159
+ cptr = (cpu_sysinfo_t *)ksp->ks_data;
160
+ volatile VALUE v_hash = rb_hash_new();
161
+
162
+ rb_hash_aset(v_hash,rb_str_new2("cpu_idle"),UINT2NUM(cptr->cpu[CPU_IDLE]));
163
+ rb_hash_aset(v_hash,rb_str_new2("cpu_user"),UINT2NUM(cptr->cpu[CPU_USER]));
164
+ rb_hash_aset(v_hash,rb_str_new2("cpu_kernel"),UINT2NUM(cptr->cpu[CPU_KERNEL]));
165
+ rb_hash_aset(v_hash,rb_str_new2("cpu_wait"),UINT2NUM(cptr->cpu[CPU_WAIT]));
166
+ rb_hash_aset(v_hash,rb_str_new2("wait_io"),UINT2NUM(cptr->wait[W_IO]));
167
+ rb_hash_aset(v_hash,rb_str_new2("wait_swap"),UINT2NUM(cptr->wait[W_SWAP]));
168
+ rb_hash_aset(v_hash,rb_str_new2("wait_pio"),UINT2NUM(cptr->wait[W_PIO]));
169
+ rb_hash_aset(v_hash,rb_str_new2("bread"),UINT2NUM(cptr->bread));
170
+ rb_hash_aset(v_hash,rb_str_new2("bwrite"),UINT2NUM(cptr->bwrite));
171
+ rb_hash_aset(v_hash,rb_str_new2("lread"),UINT2NUM(cptr->lread));
172
+ rb_hash_aset(v_hash,rb_str_new2("lwrite"),UINT2NUM(cptr->lwrite));
173
+ rb_hash_aset(v_hash,rb_str_new2("phread"),UINT2NUM(cptr->phread));
174
+ rb_hash_aset(v_hash,rb_str_new2("phwrite"),UINT2NUM(cptr->phwrite));
175
+ rb_hash_aset(v_hash,rb_str_new2("pswitch"),UINT2NUM(cptr->pswitch));
176
+ rb_hash_aset(v_hash,rb_str_new2("trap"),UINT2NUM(cptr->trap));
177
+ rb_hash_aset(v_hash,rb_str_new2("intr"),UINT2NUM(cptr->intr));
178
+ rb_hash_aset(v_hash,rb_str_new2("syscall"),UINT2NUM(cptr->syscall));
179
+ rb_hash_aset(v_hash,rb_str_new2("sysread"),UINT2NUM(cptr->sysread));
180
+ rb_hash_aset(v_hash,rb_str_new2("syswrite"),UINT2NUM(cptr->syswrite));
181
+ rb_hash_aset(v_hash,rb_str_new2("sysfork"),UINT2NUM(cptr->sysfork));
182
+ rb_hash_aset(v_hash,rb_str_new2("sysvfork"),UINT2NUM(cptr->sysvfork));
183
+ rb_hash_aset(v_hash,rb_str_new2("sysexec"),UINT2NUM(cptr->sysexec));
184
+ rb_hash_aset(v_hash,rb_str_new2("readch"),UINT2NUM(cptr->readch));
185
+ rb_hash_aset(v_hash,rb_str_new2("writech"),UINT2NUM(cptr->writech));
186
+ rb_hash_aset(v_hash,rb_str_new2("rcvint"),UINT2NUM(cptr->rcvint));
187
+ rb_hash_aset(v_hash,rb_str_new2("xmtint"),UINT2NUM(cptr->xmtint));
188
+ rb_hash_aset(v_hash,rb_str_new2("mdmint"),UINT2NUM(cptr->mdmint));
189
+ rb_hash_aset(v_hash,rb_str_new2("rawch"),UINT2NUM(cptr->rawch));
190
+ rb_hash_aset(v_hash,rb_str_new2("canch"),UINT2NUM(cptr->canch));
191
+ rb_hash_aset(v_hash,rb_str_new2("outch"),UINT2NUM(cptr->outch));
192
+ rb_hash_aset(v_hash,rb_str_new2("msg"),UINT2NUM(cptr->msg));
193
+ rb_hash_aset(v_hash,rb_str_new2("sema"),UINT2NUM(cptr->sema));
194
+ rb_hash_aset(v_hash,rb_str_new2("namei"),UINT2NUM(cptr->namei));
195
+ rb_hash_aset(v_hash,rb_str_new2("ufsiget"),UINT2NUM(cptr->ufsiget));
196
+ rb_hash_aset(v_hash,rb_str_new2("ufsdirblk"),UINT2NUM(cptr->ufsdirblk));
197
+ rb_hash_aset(v_hash,rb_str_new2("ufsipage"),UINT2NUM(cptr->ufsipage));
198
+ rb_hash_aset(v_hash,rb_str_new2("ufsinopage"),UINT2NUM(cptr->ufsinopage));
199
+ rb_hash_aset(v_hash,rb_str_new2("inodeovf"),UINT2NUM(cptr->inodeovf));
200
+ rb_hash_aset(v_hash,rb_str_new2("fileovf"),UINT2NUM(cptr->fileovf));
201
+ rb_hash_aset(v_hash,rb_str_new2("procovf"),UINT2NUM(cptr->procovf));
202
+ rb_hash_aset(v_hash,rb_str_new2("intrthread"),UINT2NUM(cptr->intrthread));
203
+ rb_hash_aset(v_hash,rb_str_new2("intrblk"),UINT2NUM(cptr->intrblk));
204
+ rb_hash_aset(v_hash,rb_str_new2("idlethread"),UINT2NUM(cptr->idlethread));
205
+ rb_hash_aset(v_hash,rb_str_new2("inv_swtch"),UINT2NUM(cptr->inv_swtch));
206
+ rb_hash_aset(v_hash,rb_str_new2("nthreads"),UINT2NUM(cptr->nthreads));
207
+ rb_hash_aset(v_hash,rb_str_new2("cpumigrate"),UINT2NUM(cptr->cpumigrate));
208
+ rb_hash_aset(v_hash,rb_str_new2("xcalls"),UINT2NUM(cptr->xcalls));
209
+ rb_hash_aset(v_hash,rb_str_new2("mutex_adenters"), UINT2NUM(cptr->mutex_adenters));
210
+ rb_hash_aset(v_hash,rb_str_new2("rw_rdfails"),UINT2NUM(cptr->rw_rdfails));
211
+ rb_hash_aset(v_hash,rb_str_new2("rw_wrfails"),UINT2NUM(cptr->rw_wrfails));
212
+ rb_hash_aset(v_hash,rb_str_new2("modload"),UINT2NUM(cptr->modload));
213
+ rb_hash_aset(v_hash,rb_str_new2("modunload"),UINT2NUM(cptr->modunload));
214
+ rb_hash_aset(v_hash,rb_str_new2("bawrite"),UINT2NUM(cptr->bawrite));
215
+
226
216
  #ifdef STATISTICS
227
- rb_hash_aset(rbHash,rb_str_new2("rw_enters"),UINT2NUM(cptr->rw_enters));
228
- rb_hash_aset(rbHash,rb_str_new2("win_uo_cnt"),UINT2NUM(cptr->win_uo_cnt));
229
- rb_hash_aset(rbHash,rb_str_new2("win_uu_cnt"),UINT2NUM(cptr->win_uu_cnt));
230
- rb_hash_aset(rbHash,rb_str_new2("win_so_cnt"),UINT2NUM(cptr->win_so_cnt));
231
- rb_hash_aset(rbHash,rb_str_new2("win_su_cnt"),UINT2NUM(cptr->win_su_cnt));
232
- rb_hash_aset(rbHash,rb_str_new2("win_suo_cnt"),UINT2NUM(cptr->win_suo_cnt));
217
+ rb_hash_aset(v_hash,rb_str_new2("rw_enters"),UINT2NUM(cptr->rw_enters));
218
+ rb_hash_aset(v_hash,rb_str_new2("win_uo_cnt"),UINT2NUM(cptr->win_uo_cnt));
219
+ rb_hash_aset(v_hash,rb_str_new2("win_uu_cnt"),UINT2NUM(cptr->win_uu_cnt));
220
+ rb_hash_aset(v_hash,rb_str_new2("win_so_cnt"),UINT2NUM(cptr->win_so_cnt));
221
+ rb_hash_aset(v_hash,rb_str_new2("win_su_cnt"),UINT2NUM(cptr->win_su_cnt));
222
+ rb_hash_aset(v_hash,rb_str_new2("win_suo_cnt"),UINT2NUM(cptr->win_suo_cnt));
233
223
  #endif
234
224
 
235
- return rbHash;
225
+ return v_hash;
236
226
  }
237
227
 
238
- /* There are several different structs possible here. We'll forward this
239
- * call to the appropriate mapper based on the module and name.
240
- *
241
- * A few names are not yet being handled.
242
- */
228
+ /* There are several different structs possible here. We'll forward this
229
+ * call to the appropriate mapper based on the module and name.
230
+ *
231
+ * A few names are not yet being handled.
232
+ */
243
233
  static VALUE map_raw_data_type(kstat_t* ksp){
244
- VALUE rbHash = rb_hash_new();
245
-
246
- if(!strcmp(ksp->ks_module,"unix")){
247
- if(!strcmp(ksp->ks_name,"vminfo")){
248
- rbHash = map_raw_vminfo(ksp);
249
- }
250
- else if(!strcmp(ksp->ks_name,"flushmeter")){
251
- rbHash = map_raw_flushmeter(ksp);
252
- }
253
- else if(!strcmp(ksp->ks_name,"ncstats")){
254
- rbHash = map_raw_ncstats(ksp);
255
- }
256
- else if(!strcmp(ksp->ks_name,"sysinfo")){
257
- rbHash = map_raw_sysinfo(ksp);
258
- }
259
- else if(!strcmp(ksp->ks_name,"var")){
260
- rbHash = map_raw_var(ksp);
261
- }
262
- else{
263
- /* Return an empty hash for unhandled names for now */
264
- rbHash = rb_hash_new();
265
- }
266
- }
267
-
268
- if(!strcmp(ksp->ks_module,"cpu_stat")){
269
- rbHash = map_raw_cpu_sysinfo(ksp);
270
- }
271
-
272
- if(!strcmp(ksp->ks_module,"nfs")){
273
- if(!strcmp(ksp->ks_name,"mntinfo")){
274
- rbHash = map_raw_mntinfo(ksp);
275
- }
276
- }
277
- return rbHash;
234
+ VALUE v_hash = rb_hash_new();
235
+
236
+ if(!strcmp(ksp->ks_module, "unix")){
237
+ if(!strcmp(ksp->ks_name, "vminfo")){
238
+ v_hash = map_raw_vminfo(ksp);
239
+ }
240
+ else if(!strcmp(ksp->ks_name, "flushmeter")){
241
+ v_hash = map_raw_flushmeter(ksp);
242
+ }
243
+ else if(!strcmp(ksp->ks_name, "ncstats")){
244
+ v_hash = map_raw_ncstats(ksp);
245
+ }
246
+ else if(!strcmp(ksp->ks_name, "sysinfo")){
247
+ v_hash = map_raw_sysinfo(ksp);
248
+ }
249
+ else if(!strcmp(ksp->ks_name, "var")){
250
+ v_hash = map_raw_var(ksp);
251
+ }
252
+ else{
253
+ // Return an empty hash for unhandled names for now
254
+ v_hash = rb_hash_new();
255
+ }
256
+ }
257
+
258
+ if(!strcmp(ksp->ks_module,"cpu_stat"))
259
+ v_hash = map_raw_cpu_sysinfo(ksp);
260
+
261
+ if(!strcmp(ksp->ks_module,"nfs")){
262
+ if(!strcmp(ksp->ks_name,"mntinfo")){
263
+ v_hash = map_raw_mntinfo(ksp);
264
+ }
265
+ }
266
+
267
+ return v_hash;
278
268
  }
279
269
 
280
270
  static VALUE map_timer_data_type(kstat_timer_t* t){
281
- volatile VALUE rbHash = rb_hash_new();
271
+ volatile VALUE v_hash = rb_hash_new();
282
272
 
283
- rb_hash_aset(rbHash,rb_str_new2("name"),rb_str_new2(t->name));
284
- rb_hash_aset(rbHash,rb_str_new2("num_events"),ULL2NUM(t->num_events));
285
- rb_hash_aset(rbHash,rb_str_new2("elapsed_time"),ULL2NUM(t->elapsed_time));
286
- rb_hash_aset(rbHash,rb_str_new2("min_time"),ULL2NUM(t->min_time));
287
- rb_hash_aset(rbHash,rb_str_new2("max_time"),ULL2NUM(t->max_time));
288
- rb_hash_aset(rbHash,rb_str_new2("start_time"),ULL2NUM(t->start_time));
289
- rb_hash_aset(rbHash,rb_str_new2("stop_time"),ULL2NUM(t->stop_time));
273
+ rb_hash_aset(v_hash,rb_str_new2("name"),rb_str_new2(t->name));
274
+ rb_hash_aset(v_hash,rb_str_new2("num_events"),ULL2NUM(t->num_events));
275
+ rb_hash_aset(v_hash,rb_str_new2("elapsed_time"),ULL2NUM(t->elapsed_time));
276
+ rb_hash_aset(v_hash,rb_str_new2("min_time"),ULL2NUM(t->min_time));
277
+ rb_hash_aset(v_hash,rb_str_new2("max_time"),ULL2NUM(t->max_time));
278
+ rb_hash_aset(v_hash,rb_str_new2("start_time"),ULL2NUM(t->start_time));
279
+ rb_hash_aset(v_hash,rb_str_new2("stop_time"),ULL2NUM(t->stop_time));
290
280
 
291
- return rbHash;
281
+ return v_hash;
292
282
  }
293
283
 
294
284
  static VALUE map_intr_data_type(kstat_t* ksp){
295
- int i;
296
- kstat_intr_t* kp;
297
- kp = (kstat_intr_t *)ksp->ks_data;
298
- VALUE rbHash = rb_hash_new();
299
- static char* intr_names[] =
300
- {"hard", "soft", "watchdog", "spurious", "multiple_service"};
301
-
302
- for(i = 0; i < KSTAT_NUM_INTRS; i++){
303
- rb_hash_aset(rbHash,rb_str_new2(intr_names[i]),UINT2NUM(kp->intrs[i]));
304
- }
305
-
306
- return rbHash;
285
+ int i;
286
+ kstat_intr_t* kp;
287
+ kp = (kstat_intr_t *)ksp->ks_data;
288
+ VALUE v_hash = rb_hash_new();
289
+ static char* intr_names[] =
290
+ {"hard", "soft", "watchdog", "spurious", "multiple_service"};
291
+
292
+ for(i = 0; i < KSTAT_NUM_INTRS; i++)
293
+ rb_hash_aset(v_hash,rb_str_new2(intr_names[i]),UINT2NUM(kp->intrs[i]));
294
+
295
+ return v_hash;
307
296
  }
308
297
 
309
298
  static VALUE map_io_data_type(kstat_io_t* k){
310
- volatile VALUE rbHash = rb_hash_new();
311
-
312
- rb_hash_aset(rbHash,rb_str_new2("nread"),ULL2NUM(k->nread));
313
- rb_hash_aset(rbHash,rb_str_new2("nwritten"),ULL2NUM(k->nwritten));
314
- rb_hash_aset(rbHash,rb_str_new2("reads"),UINT2NUM(k->reads));
315
- rb_hash_aset(rbHash,rb_str_new2("writes"),UINT2NUM(k->writes));
316
- rb_hash_aset(rbHash,rb_str_new2("wtime"),ULL2NUM(k->wtime));
317
- rb_hash_aset(rbHash,rb_str_new2("wlentime"),ULL2NUM(k->wlentime));
318
- rb_hash_aset(rbHash,rb_str_new2("wlastupdate"),ULL2NUM(k->wlastupdate));
319
- rb_hash_aset(rbHash,rb_str_new2("rtime"),ULL2NUM(k->rtime));
320
- rb_hash_aset(rbHash,rb_str_new2("rlentime"),ULL2NUM(k->rlentime));
321
- rb_hash_aset(rbHash,rb_str_new2("rlastupdate"),ULL2NUM(k->rlastupdate));
322
- rb_hash_aset(rbHash,rb_str_new2("wcnt"),UINT2NUM(k->wcnt));
323
- rb_hash_aset(rbHash,rb_str_new2("rcnt"),UINT2NUM(k->rcnt));
324
-
325
- return rbHash;
299
+ volatile VALUE v_hash = rb_hash_new();
300
+
301
+ rb_hash_aset(v_hash,rb_str_new2("nread"),ULL2NUM(k->nread));
302
+ rb_hash_aset(v_hash,rb_str_new2("nwritten"),ULL2NUM(k->nwritten));
303
+ rb_hash_aset(v_hash,rb_str_new2("reads"),UINT2NUM(k->reads));
304
+ rb_hash_aset(v_hash,rb_str_new2("writes"),UINT2NUM(k->writes));
305
+ rb_hash_aset(v_hash,rb_str_new2("wtime"),ULL2NUM(k->wtime));
306
+ rb_hash_aset(v_hash,rb_str_new2("wlentime"),ULL2NUM(k->wlentime));
307
+ rb_hash_aset(v_hash,rb_str_new2("wlastupdate"),ULL2NUM(k->wlastupdate));
308
+ rb_hash_aset(v_hash,rb_str_new2("rtime"),ULL2NUM(k->rtime));
309
+ rb_hash_aset(v_hash,rb_str_new2("rlentime"),ULL2NUM(k->rlentime));
310
+ rb_hash_aset(v_hash,rb_str_new2("rlastupdate"),ULL2NUM(k->rlastupdate));
311
+ rb_hash_aset(v_hash,rb_str_new2("wcnt"),UINT2NUM(k->wcnt));
312
+ rb_hash_aset(v_hash,rb_str_new2("rcnt"),UINT2NUM(k->rcnt));
313
+
314
+ return v_hash;
326
315
  }
327
316
 
328
317
  static VALUE map_named_data_type(kstat_t* ksp){
329
- volatile VALUE rbHash;
330
- kstat_named_t* knp;
331
- knp = (kstat_named_t *)ksp->ks_data;
332
- int i;
333
-
334
- rbHash = rb_hash_new();
335
-
336
- for(i = 0; i < ksp->ks_ndata; i++, knp++)
337
- {
338
- switch (knp->data_type)
339
- {
340
- case KSTAT_DATA_CHAR:
341
- hash_add_pair(rbHash,knp->name,knp->value.c);
342
- break;
343
- case KSTAT_DATA_INT32:
344
- rb_hash_aset(rbHash,rb_str_new2(knp->name),INT2NUM(knp->value.i32));
345
- break;
346
- case KSTAT_DATA_UINT32:
347
- rb_hash_aset(rbHash,rb_str_new2(knp->name),UINT2NUM(knp->value.ui32));
348
- break;
349
- case KSTAT_DATA_INT64:
350
- rb_hash_aset(rbHash,rb_str_new2(knp->name),LL2NUM(knp->value.i64));
351
- break;
352
- case KSTAT_DATA_UINT64:
353
- rb_hash_aset(rbHash,rb_str_new2(knp->name),ULL2NUM(knp->value.ui64));
354
- break;
355
- default:
356
- hash_add_pair(rbHash,knp->name,"Unknown");
357
- break;
358
- }
359
- }
360
- return rbHash;
318
+ volatile VALUE v_hash;
319
+ kstat_named_t* knp;
320
+ knp = (kstat_named_t *)ksp->ks_data;
321
+ int i;
322
+
323
+ v_hash = rb_hash_new();
324
+
325
+ for(i = 0; i < ksp->ks_ndata; i++, knp++){
326
+ switch (knp->data_type){
327
+ case KSTAT_DATA_CHAR:
328
+ hash_add_pair(v_hash,knp->name,knp->value.c);
329
+ break;
330
+ case KSTAT_DATA_INT32:
331
+ rb_hash_aset(v_hash,rb_str_new2(knp->name),INT2NUM(knp->value.i32));
332
+ break;
333
+ case KSTAT_DATA_UINT32:
334
+ rb_hash_aset(v_hash,rb_str_new2(knp->name),UINT2NUM(knp->value.ui32));
335
+ break;
336
+ case KSTAT_DATA_INT64:
337
+ rb_hash_aset(v_hash,rb_str_new2(knp->name),LL2NUM(knp->value.i64));
338
+ break;
339
+ case KSTAT_DATA_UINT64:
340
+ rb_hash_aset(v_hash,rb_str_new2(knp->name),ULL2NUM(knp->value.ui64));
341
+ break;
342
+ default:
343
+ hash_add_pair(v_hash,knp->name,"Unknown");
344
+ break;
345
+ }
346
+ }
347
+
348
+ return v_hash;
361
349
  }
362
350
 
363
351
  #ifdef __cplusplus