6 static const char *memcached_stat_keys
[] = {
19 "connection_structures",
34 memcached_stat_fn func
;
40 static memcached_return_t
set_data(memcached_stat_st
*memc_stat
, char *key
, char *value
)
45 WATCHPOINT_STRING(key
);
46 return MEMCACHED_UNKNOWN_STAT_KEY
;
48 else if (!strcmp("pid", key
))
50 memc_stat
->pid
= (uint32_t) strtol(value
, (char **)NULL
, 10);
52 else if (!strcmp("uptime", key
))
54 memc_stat
->uptime
= (uint32_t) strtol(value
, (char **)NULL
, 10);
56 else if (!strcmp("time", key
))
58 memc_stat
->time
= (uint32_t) strtol(value
, (char **)NULL
, 10);
60 else if (!strcmp("version", key
))
62 memcpy(memc_stat
->version
, value
, strlen(value
));
63 memc_stat
->version
[strlen(value
)]= 0;
65 else if (!strcmp("pointer_size", key
))
67 memc_stat
->pointer_size
= (uint32_t) strtol(value
, (char **)NULL
, 10);
69 else if (!strcmp("rusage_user", key
))
72 for (walk_ptr
= value
; (!ispunct(*walk_ptr
)); walk_ptr
++);
75 memc_stat
->rusage_user_seconds
= (uint32_t) strtol(value
, (char **)NULL
, 10);
76 memc_stat
->rusage_user_microseconds
= (uint32_t) strtol(walk_ptr
, (char **)NULL
, 10);
78 else if (!strcmp("rusage_system", key
))
81 for (walk_ptr
= value
; (!ispunct(*walk_ptr
)); walk_ptr
++);
84 memc_stat
->rusage_system_seconds
= (uint32_t) strtol(value
, (char **)NULL
, 10);
85 memc_stat
->rusage_system_microseconds
= (uint32_t) strtol(walk_ptr
, (char **)NULL
, 10);
87 else if (!strcmp("curr_items", key
))
89 memc_stat
->curr_items
= (uint32_t) strtol(value
, (char **)NULL
, 10);
91 else if (!strcmp("total_items", key
))
93 memc_stat
->total_items
= (uint32_t) strtol(value
, (char **)NULL
, 10);
95 else if (!strcmp("bytes_read", key
))
97 memc_stat
->bytes_read
= (uint32_t) strtoll(value
, (char **)NULL
, 10);
99 else if (!strcmp("bytes_written", key
))
101 memc_stat
->bytes_written
= (uint32_t) strtoll(value
, (char **)NULL
, 10);
103 else if (!strcmp("bytes", key
))
105 memc_stat
->bytes
= (uint32_t) strtoll(value
, (char **)NULL
, 10);
107 else if (!strcmp("curr_connections", key
))
109 memc_stat
->curr_connections
= (uint32_t) strtoll(value
, (char **)NULL
, 10);
111 else if (!strcmp("total_connections", key
))
113 memc_stat
->total_connections
= (uint32_t) strtoll(value
, (char **)NULL
, 10);
115 else if (!strcmp("connection_structures", key
))
117 memc_stat
->connection_structures
= (uint32_t) strtol(value
, (char **)NULL
, 10);
119 else if (!strcmp("cmd_get", key
))
121 memc_stat
->cmd_get
= (uint64_t) strtoll(value
, (char **)NULL
, 10);
123 else if (!strcmp("cmd_set", key
))
125 memc_stat
->cmd_set
= (uint64_t) strtoll(value
, (char **)NULL
, 10);
127 else if (!strcmp("get_hits", key
))
129 memc_stat
->get_hits
= (uint64_t) strtoll(value
, (char **)NULL
, 10);
131 else if (!strcmp("get_misses", key
))
133 memc_stat
->get_misses
= (uint64_t)strtoll(value
, (char **)NULL
, 10);
135 else if (!strcmp("evictions", key
))
137 memc_stat
->evictions
= (uint64_t)strtoll(value
, (char **)NULL
, 10);
139 else if (!strcmp("limit_maxbytes", key
))
141 memc_stat
->limit_maxbytes
= (uint64_t) strtoll(value
, (char **)NULL
, 10);
143 else if (!strcmp("threads", key
))
145 memc_stat
->threads
= (uint32_t) strtol(value
, (char **)NULL
, 10);
147 else if (!(strcmp("delete_misses", key
) == 0 ||/* New stats in the 1.3 beta */
148 strcmp("delete_hits", key
) == 0 ||/* Just swallow them for now.. */
149 strcmp("incr_misses", key
) == 0 ||
150 strcmp("incr_hits", key
) == 0 ||
151 strcmp("decr_misses", key
) == 0 ||
152 strcmp("decr_hits", key
) == 0 ||
153 strcmp("cas_misses", key
) == 0 ||
154 strcmp("cas_hits", key
) == 0 ||
155 strcmp("cas_badval", key
) == 0 ||
156 strcmp("cmd_flush", key
) == 0 ||
157 strcmp("accepting_conns", key
) == 0 ||
158 strcmp("listen_disabled_num", key
) == 0 ||
159 strcmp("conn_yields", key
) == 0 ||
160 strcmp("auth_cmds", key
) == 0 ||
161 strcmp("auth_errors", key
) == 0 ||
162 strcmp("reclaimed", key
) == 0))
164 WATCHPOINT_STRING(key
);
165 /* return MEMCACHED_UNKNOWN_STAT_KEY; */
166 return MEMCACHED_SUCCESS
;
169 return MEMCACHED_SUCCESS
;
172 char *memcached_stat_get_value(const memcached_st
*ptr
, memcached_stat_st
*memc_stat
,
173 const char *key
, memcached_return_t
*error
)
175 char buffer
[SMALL_STRING_LEN
];
179 *error
= MEMCACHED_SUCCESS
;
181 if (!memcmp("pid", key
, sizeof("pid") -1))
182 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%u", memc_stat
->pid
);
183 else if (!memcmp("uptime", key
, sizeof("uptime") -1))
184 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%u", memc_stat
->uptime
);
185 else if (!memcmp("time", key
, sizeof("time") -1))
186 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%llu", (unsigned long long)memc_stat
->time
);
187 else if (!memcmp("version", key
, sizeof("version") -1))
188 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%s", memc_stat
->version
);
189 else if (!memcmp("pointer_size", key
, sizeof("pointer_size") -1))
190 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%u", memc_stat
->pointer_size
);
191 else if (!memcmp("rusage_user", key
, sizeof("rusage_user") -1))
192 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%u.%u", memc_stat
->rusage_user_seconds
, memc_stat
->rusage_user_microseconds
);
193 else if (!memcmp("rusage_system", key
, sizeof("rusage_system") -1))
194 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%u.%u", memc_stat
->rusage_system_seconds
, memc_stat
->rusage_system_microseconds
);
195 else if (!memcmp("curr_items", key
, sizeof("curr_items") -1))
196 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%u", memc_stat
->curr_items
);
197 else if (!memcmp("total_items", key
, sizeof("total_items") -1))
198 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%u", memc_stat
->total_items
);
199 else if (!memcmp("curr_connections", key
, sizeof("curr_connections") -1))
200 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%u", memc_stat
->curr_connections
);
201 else if (!memcmp("total_connections", key
, sizeof("total_connections") -1))
202 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%u", memc_stat
->total_connections
);
203 else if (!memcmp("connection_structures", key
, sizeof("connection_structures") -1))
204 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%u", memc_stat
->connection_structures
);
205 else if (!memcmp("cmd_get", key
, sizeof("cmd_get") -1))
206 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%llu", (unsigned long long)memc_stat
->cmd_get
);
207 else if (!memcmp("cmd_set", key
, sizeof("cmd_set") -1))
208 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%llu", (unsigned long long)memc_stat
->cmd_set
);
209 else if (!memcmp("get_hits", key
, sizeof("get_hits") -1))
210 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%llu", (unsigned long long)memc_stat
->get_hits
);
211 else if (!memcmp("get_misses", key
, sizeof("get_misses") -1))
212 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%llu", (unsigned long long)memc_stat
->get_misses
);
213 else if (!memcmp("evictions", key
, sizeof("evictions") -1))
214 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%llu", (unsigned long long)memc_stat
->evictions
);
215 else if (!memcmp("bytes_read", key
, sizeof("bytes_read") -1))
216 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%llu", (unsigned long long)memc_stat
->bytes_read
);
217 else if (!memcmp("bytes_written", key
, sizeof("bytes_written") -1))
218 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%llu", (unsigned long long)memc_stat
->bytes_written
);
219 else if (!memcmp("bytes", key
, sizeof("bytes") -1))
220 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%llu", (unsigned long long)memc_stat
->bytes
);
221 else if (!memcmp("limit_maxbytes", key
, sizeof("limit_maxbytes") -1))
222 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%llu", (unsigned long long)memc_stat
->limit_maxbytes
);
223 else if (! memcmp("threads", key
, sizeof("threads") -1))
224 length
= snprintf(buffer
, SMALL_STRING_LEN
,"%u", memc_stat
->threads
);
227 *error
= MEMCACHED_NOTFOUND
;
231 if (length
>= SMALL_STRING_LEN
|| length
< 0)
233 *error
= MEMCACHED_FAILURE
;
237 ret
= libmemcached_malloc(ptr
, (size_t) (length
+ 1));
238 memcpy(ret
, buffer
, (size_t) length
);
244 static memcached_return_t
binary_stats_fetch(memcached_stat_st
*memc_stat
,
246 memcached_server_write_instance_st instance
,
247 struct local_context
*check
)
249 memcached_return_t rc
;
251 char buffer
[MEMCACHED_DEFAULT_COMMAND_SIZE
];
252 protocol_binary_request_stats request
= {.bytes
= {0}};
253 request
.message
.header
.request
.magic
= PROTOCOL_BINARY_REQ
;
254 request
.message
.header
.request
.opcode
= PROTOCOL_BINARY_CMD_STAT
;
255 request
.message
.header
.request
.datatype
= PROTOCOL_BINARY_RAW_BYTES
;
259 size_t len
= strlen(args
);
261 rc
= memcached_validate_key_length(len
, true);
262 unlikely (rc
!= MEMCACHED_SUCCESS
)
265 request
.message
.header
.request
.keylen
= htons((uint16_t)len
);
266 request
.message
.header
.request
.bodylen
= htonl((uint32_t) len
);
268 struct libmemcached_io_vector_st vector
[]=
270 { .length
= sizeof(request
.bytes
), .buffer
= request
.bytes
},
271 { .length
= len
, .buffer
= args
}
274 if (memcached_vdo(instance
, vector
, 2, true) != MEMCACHED_SUCCESS
)
276 memcached_io_reset(instance
);
277 return MEMCACHED_WRITE_FAILURE
;
282 if (memcached_do(instance
, request
.bytes
,
283 sizeof(request
.bytes
), true) != MEMCACHED_SUCCESS
)
285 memcached_io_reset(instance
);
286 return MEMCACHED_WRITE_FAILURE
;
290 memcached_server_response_decrement(instance
);
293 rc
= memcached_response(instance
, buffer
, sizeof(buffer
), NULL
);
295 if (rc
== MEMCACHED_END
)
298 unlikely (rc
!= MEMCACHED_SUCCESS
)
300 memcached_io_reset(instance
);
306 unlikely((set_data(memc_stat
, buffer
, buffer
+ strlen(buffer
) + 1)) == MEMCACHED_UNKNOWN_STAT_KEY
)
308 WATCHPOINT_ERROR(MEMCACHED_UNKNOWN_STAT_KEY
);
309 WATCHPOINT_ASSERT(0);
313 if (check
&& check
->func
)
315 size_t key_length
= strlen(buffer
);
317 check
->func(instance
,
319 buffer
+key_length
+1, strlen(buffer
+key_length
+1),
324 /* shit... memcached_response will decrement the counter, so I need to
325 ** reset it.. todo: look at this and try to find a better solution.
327 instance
->cursor_active
= 0;
329 return MEMCACHED_SUCCESS
;
332 static memcached_return_t
ascii_stats_fetch(memcached_stat_st
*memc_stat
,
334 memcached_server_write_instance_st instance
,
335 struct local_context
*check
)
337 memcached_return_t rc
;
338 char buffer
[MEMCACHED_DEFAULT_COMMAND_SIZE
];
342 send_length
= (size_t) snprintf(buffer
, MEMCACHED_DEFAULT_COMMAND_SIZE
,
343 "stats %s\r\n", args
);
345 send_length
= (size_t) snprintf(buffer
, MEMCACHED_DEFAULT_COMMAND_SIZE
,
348 if (send_length
>= MEMCACHED_DEFAULT_COMMAND_SIZE
|| send_length
< 0)
349 return MEMCACHED_WRITE_FAILURE
;
351 rc
= memcached_do(instance
, buffer
, (size_t)send_length
, true);
352 if (rc
!= MEMCACHED_SUCCESS
)
357 rc
= memcached_response(instance
, buffer
, MEMCACHED_DEFAULT_COMMAND_SIZE
, NULL
);
359 if (rc
== MEMCACHED_STAT
)
361 char *string_ptr
, *end_ptr
;
365 string_ptr
+= 5; /* Move past STAT */
366 for (end_ptr
= string_ptr
; isgraph(*end_ptr
); end_ptr
++);
368 key
[(size_t)(end_ptr
-string_ptr
)]= 0;
370 string_ptr
= end_ptr
+ 1;
371 for (end_ptr
= string_ptr
; !(isspace(*end_ptr
)); end_ptr
++);
373 value
[(size_t)(end_ptr
-string_ptr
)]= 0;
374 string_ptr
= end_ptr
+ 2;
377 unlikely((set_data(memc_stat
, key
, value
)) == MEMCACHED_UNKNOWN_STAT_KEY
)
379 WATCHPOINT_ERROR(MEMCACHED_UNKNOWN_STAT_KEY
);
380 WATCHPOINT_ASSERT(0);
384 if (check
&& check
->func
)
386 check
->func(instance
,
388 value
, strlen(value
),
397 if (rc
== MEMCACHED_END
)
398 return MEMCACHED_SUCCESS
;
403 memcached_stat_st
*memcached_stat(memcached_st
*self
, char *args
, memcached_return_t
*error
)
405 memcached_return_t rc
;
406 memcached_stat_st
*stats
;
408 if ((rc
= initialize_query(self
)) != MEMCACHED_SUCCESS
)
416 WATCHPOINT_ASSERT(error
);
418 unlikely (self
->flags
.use_udp
)
421 *error
= MEMCACHED_NOT_SUPPORTED
;
426 stats
= libmemcached_calloc(self
, memcached_server_count(self
), sizeof(memcached_stat_st
));
431 *error
= MEMCACHED_MEMORY_ALLOCATION_FAILURE
;
436 WATCHPOINT_ASSERT(rc
== MEMCACHED_SUCCESS
);
437 rc
= MEMCACHED_SUCCESS
;
438 for (uint32_t x
= 0; x
< memcached_server_count(self
); x
++)
440 memcached_return_t temp_return
;
441 memcached_server_write_instance_st instance
;
442 memcached_stat_st
*stat_instance
;
444 stat_instance
= stats
+ x
;
446 stat_instance
->root
= self
;
448 instance
= memcached_server_instance_fetch(self
, x
);
450 if (self
->flags
.binary_protocol
)
452 temp_return
= binary_stats_fetch(stat_instance
, args
, instance
, NULL
);
456 temp_return
= ascii_stats_fetch(stat_instance
, args
, instance
, NULL
);
459 if (temp_return
!= MEMCACHED_SUCCESS
)
460 rc
= MEMCACHED_SOME_ERRORS
;
469 memcached_return_t
memcached_stat_servername(memcached_stat_st
*memc_stat
, char *args
,
470 const char *hostname
, in_port_t port
)
473 memcached_st
*memc_ptr
;
474 memcached_server_write_instance_st instance
;
476 memset(memc_stat
, 0, sizeof(memcached_stat_st
));
478 memc_ptr
= memcached_create(&memc
);
480 return MEMCACHED_MEMORY_ALLOCATION_FAILURE
;
482 memcached_server_add(&memc
, hostname
, port
);
484 memcached_return_t rc
;
485 if ((rc
= initialize_query(memc_ptr
)) != MEMCACHED_SUCCESS
)
490 instance
= memcached_server_instance_fetch(memc_ptr
, 0);
492 if (memc
.flags
.binary_protocol
)
494 rc
= binary_stats_fetch(memc_stat
, args
, instance
, NULL
);
498 rc
= ascii_stats_fetch(memc_stat
, args
, instance
, NULL
);
501 memcached_free(&memc
);
507 We make a copy of the keys since at some point in the not so distant future
508 we will add support for "found" keys.
510 char ** memcached_stat_get_keys(const memcached_st
*ptr
,
511 memcached_stat_st
*memc_stat
,
512 memcached_return_t
*error
)
515 size_t length
= sizeof(memcached_stat_keys
);
519 list
= libmemcached_malloc(ptr
, length
);
523 *error
= MEMCACHED_MEMORY_ALLOCATION_FAILURE
;
527 memcpy(list
, memcached_stat_keys
, sizeof(memcached_stat_keys
));
529 *error
= MEMCACHED_SUCCESS
;
534 void memcached_stat_free(const memcached_st
*ptr
, memcached_stat_st
*memc_stat
)
536 if (memc_stat
== NULL
)
538 WATCHPOINT_ASSERT(0); /* Be polite, but when debugging catch this as an error */
544 libmemcached_free(memc_stat
->root
, memc_stat
);
548 libmemcached_free(ptr
, memc_stat
);
556 static memcached_return_t
call_stat_fn(memcached_st
*ptr
,
557 memcached_server_write_instance_st instance
,
560 memcached_return_t rc
;
561 struct local_context
*check
= (struct local_context
*)context
;
563 if (ptr
->flags
.binary_protocol
)
565 rc
= binary_stats_fetch(NULL
, check
->args
, instance
, check
);
569 rc
= ascii_stats_fetch(NULL
, check
->args
, instance
, check
);
575 memcached_return_t
memcached_stat_execute(memcached_st
*memc
, const char *args
, memcached_stat_fn func
, void *context
)
577 memcached_version(memc
);
579 struct local_context check
= { .func
= func
, .context
= context
, .args
= args
};
581 return memcached_server_execute(memc
, call_stat_fn
, (void *)&check
);