solaris-kstat 1.0.1 → 1.0.2

Sign up to get free protection for your applications and to get access to all the features.
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