#ifndef __DragonFly__

#include "uwsgi.h"

#endif

#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__DragonFly__) || defined(__OpenBSD__)

#include <sys/user.h>

#include <sys/sysctl.h>

#include <kvm.h>

#elif defined(__sun__)

/* Terrible Hack !!! */

#ifndef _LP64

#undef _FILE_OFFSET_BITS

#endif

#include <procfs.h>

#define _FILE_OFFSET_BITS 64

#endif

#ifdef __DragonFly__

#include "uwsgi.h"

#endif

extern struct uwsgi_server uwsgi;

//use this instead of fprintf to avoid buffering mess with udp logging

void uwsgi_log(const char *fmt, ...) {

va_list ap;

char logpkt[4096];

int rlen = 0;

int ret;

struct timeval tv;

char sftime[64];

char ctime_storage[26];

time_t now;

if (uwsgi.logdate) {

if (uwsgi.log_strftime) {

now = uwsgi_now();

rlen = strftime(sftime, 64, uwsgi.log_strftime, localtime(&now));

memcpy(logpkt, sftime, rlen);

memcpy(logpkt + rlen, " - ", 3);

rlen += 3;

}

else {

gettimeofday(&tv, NULL);

#if defined(__sun__) && !defined(__clang__)

ctime_r((const time_t *) &tv.tv_sec, ctime_storage, 26);

#else

ctime_r((const time_t *) &tv.tv_sec, ctime_storage);

#endif

memcpy(logpkt, ctime_storage, 24);

memcpy(logpkt + 24, " - ", 3);

rlen = 24 + 3;

}

}

va_start(ap, fmt);

ret = vsnprintf(logpkt + rlen, 4096 - rlen, fmt, ap);

va_end(ap);

if (ret >= 4096) {

char *tmp_buf = uwsgi_malloc(rlen + ret + 1);

memcpy(tmp_buf, logpkt, rlen);

va_start(ap, fmt);

ret = vsnprintf(tmp_buf + rlen, ret + 1, fmt, ap);

va_end(ap);

rlen = write(2, tmp_buf, rlen + ret);

free(tmp_buf);

return;

}

rlen += ret;

// do not check for errors

rlen = write(2, logpkt, rlen);

}

void uwsgi_log_verbose(const char *fmt, ...) {

va_list ap;

char logpkt[4096];

int rlen = 0;

struct timeval tv;

char sftime[64];

time_t now;

char ctime_storage[26];

if (uwsgi.log_strftime) {

now = uwsgi_now();

rlen = strftime(sftime, 64, uwsgi.log_strftime, localtime(&now));

memcpy(logpkt, sftime, rlen);

memcpy(logpkt + rlen, " - ", 3);

rlen += 3;

}

else {

gettimeofday(&tv, NULL);

#if defined(__sun__) && !defined(__clang__)

ctime_r((const time_t *) &tv.tv_sec, ctime_storage, 26);

#else

ctime_r((const time_t *) &tv.tv_sec, ctime_storage);

#endif

memcpy(logpkt, ctime_storage, 24);

memcpy(logpkt + 24, " - ", 3);

rlen = 24 + 3;

}

va_start(ap, fmt);

rlen += vsnprintf(logpkt + rlen, 4096 - rlen, fmt, ap);

va_end(ap);

// do not check for errors

rlen = write(2, logpkt, rlen);

}

/*

commodity function mainly useful in log rotation

*/

void uwsgi_logfile_write(const char *fmt, ...) {

va_list ap;

char logpkt[4096];

struct timeval tv;

char ctime_storage[26];

gettimeofday(&tv, NULL);

#if defined(__sun__) && !defined(__clang__)

ctime_r((const time_t *) &tv.tv_sec, ctime_storage, 26);

#else

ctime_r((const time_t *) &tv.tv_sec, ctime_storage);

#endif

memcpy(logpkt, ctime_storage, 24);

memcpy(logpkt + 24, " - ", 3);

int rlen = 24 + 3;

va_start(ap, fmt);

rlen += vsnprintf(logpkt + rlen, 4096 - rlen, fmt, ap);

va_end(ap);

// do not check for errors

rlen = write(uwsgi.original_log_fd, logpkt, rlen);

}

static void fix_logpipe_buf(int *fd) {

int so_bufsize;

socklen_t so_bufsize_len = sizeof(int);

if (getsockopt(fd[0], SOL_SOCKET, SO_RCVBUF, &so_bufsize, &so_bufsize_len)) {

uwsgi_error("fix_logpipe_buf()/getsockopt()");

return;

}

if ((size_t)so_bufsize < uwsgi.log_master_bufsize) {

so_bufsize = uwsgi.log_master_bufsize;

if (setsockopt(fd[0], SOL_SOCKET, SO_RCVBUF, &so_bufsize, so_bufsize_len)) {

uwsgi_error("fix_logpipe_buf()/setsockopt()");

}

}

if (getsockopt(fd[1], SOL_SOCKET, SO_SNDBUF, &so_bufsize, &so_bufsize_len)) {

uwsgi_error("fix_logpipe_buf()/getsockopt()");

return;

}

if ((size_t)so_bufsize < uwsgi.log_master_bufsize) {

so_bufsize = uwsgi.log_master_bufsize;

if (setsockopt(fd[1], SOL_SOCKET, SO_SNDBUF, &so_bufsize, so_bufsize_len)) {

uwsgi_error("fix_logpipe_buf()/setsockopt()");

}

}

}

// create the logpipe

void create_logpipe(void) {

if (uwsgi.log_master_stream) {

if (socketpair(AF_UNIX, SOCK_STREAM, 0, uwsgi.shared->worker_log_pipe)) {

uwsgi_error("create_logpipe()/socketpair()\n");

exit(1);

}

}

else {

#if defined(SOCK_SEQPACKET) && defined(__linux__)

if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, uwsgi.shared->worker_log_pipe)) {

#else

if (socketpair(AF_UNIX, SOCK_DGRAM, 0, uwsgi.shared->worker_log_pipe)) {

#endif

uwsgi_error("create_logpipe()/socketpair()\n");

exit(1);

}

fix_logpipe_buf(uwsgi.shared->worker_log_pipe);

}

uwsgi_socket_nb(uwsgi.shared->worker_log_pipe[0]);

uwsgi_socket_nb(uwsgi.shared->worker_log_pipe[1]);

if (uwsgi.shared->worker_log_pipe[1] != 1) {

if (dup2(uwsgi.shared->worker_log_pipe[1], 1) < 0) {

uwsgi_error("dup2()");

exit(1);

}

}

if (dup2(1, 2) < 0) {

uwsgi_error("dup2()");

exit(1);

}

if (uwsgi.req_log_master) {

if (uwsgi.log_master_req_stream) {

if (socketpair(AF_UNIX, SOCK_STREAM, 0, uwsgi.shared->worker_req_log_pipe)) {

uwsgi_error("create_logpipe()/socketpair()\n");

exit(1);

}

}

else {

#if defined(SOCK_SEQPACKET) && defined(__linux__)

if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, uwsgi.shared->worker_req_log_pipe)) {

#else

if (socketpair(AF_UNIX, SOCK_DGRAM, 0, uwsgi.shared->worker_req_log_pipe)) {

#endif

uwsgi_error("create_logpipe()/socketpair()\n");

exit(1);

}

fix_logpipe_buf(uwsgi.shared->worker_req_log_pipe);

}

uwsgi_socket_nb(uwsgi.shared->worker_req_log_pipe[0]);

uwsgi_socket_nb(uwsgi.shared->worker_req_log_pipe[1]);

uwsgi.req_log_fd = uwsgi.shared->worker_req_log_pipe[1];

}

}

// log to the specified file or udp address

void logto(char *logfile) {

int fd;

char *udp_port;

struct sockaddr_in udp_addr;

udp_port = strchr(logfile, ':');

if (udp_port) {

udp_port[0] = 0;

if (!udp_port[1] || !logfile[0]) {

uwsgi_log("invalid udp address\n");

exit(1);

}

fd = socket(AF_INET, SOCK_DGRAM, 0);

if (fd < 0) {

uwsgi_error("socket()");

exit(1);

}

memset(&udp_addr, 0, sizeof(struct sockaddr_in));

udp_addr.sin_family = AF_INET;

udp_addr.sin_port = htons(atoi(udp_port + 1));

char *resolved = uwsgi_resolve_ip(logfile);

if (resolved) {

udp_addr.sin_addr.s_addr = inet_addr(resolved);

}

else {

udp_addr.sin_addr.s_addr = inet_addr(logfile);

}

if (connect(fd, (const struct sockaddr *) &udp_addr, sizeof(struct sockaddr_in)) < 0) {

uwsgi_error("connect()");

exit(1);

}

}

else {

if (uwsgi.log_truncate) {

fd = open(logfile, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP);

}

else {

fd = open(logfile, O_RDWR | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR | S_IRGRP);

}

if (fd < 0) {

uwsgi_error_open(logfile);

exit(1);

}

uwsgi.logfile = logfile;

if (uwsgi.chmod_logfile_value) {

if (fchmod(fd, uwsgi.chmod_logfile_value)) {

uwsgi_error("fchmod()");

}

}

}

// if the log-master is already active, just re-set the original_log_fd

if (uwsgi.shared->worker_log_pipe[0] == -1) {

/* stdout */

if (fd != 1) {

if (dup2(fd, 1) < 0) {

uwsgi_error("dup2()");

exit(1);

}

close(fd);

}

/* stderr */

if (dup2(1, 2) < 0) {

uwsgi_error("dup2()");

exit(1);

}

uwsgi.original_log_fd = 2;

}

else {

uwsgi.original_log_fd = fd;

}

}

void uwsgi_setup_log() {

uwsgi_setup_log_encoders();

if (uwsgi.daemonize) {

if (uwsgi.has_emperor) {

logto(uwsgi.daemonize);

}

else {

if (!uwsgi.is_a_reload) {

daemonize(uwsgi.daemonize);

}

else if (uwsgi.log_reopen) {

logto(uwsgi.daemonize);

}

}

}

else if (uwsgi.logfile) {

if (!uwsgi.is_a_reload || uwsgi.log_reopen) {

logto(uwsgi.logfile);

}

}

}

static struct uwsgi_logger *setup_chosen_logger(struct uwsgi_string_list *usl) {

char *id = NULL;

char *name = usl->value;

char *space = strchr(name, ' ');

if (space) {

int is_id = 1;

int i;

for (i = 0; i < (space - name); i++) {

if (!isalnum((int)name[i])) {

is_id = 0;

break;

}

}

if (is_id) {

id = uwsgi_concat2n(name, space - name, "", 0);

name = space + 1;

}

}

char *colon = strchr(name, ':');

if (colon) {

*colon = 0;

}

struct uwsgi_logger *chosen_logger = uwsgi_get_logger(name);

if (!chosen_logger) {

uwsgi_log("unable to find logger '%s'\n", name);

exit(1);

}

// make a copy of the logger

struct uwsgi_logger *copy_of_chosen_logger = uwsgi_malloc(sizeof(struct uwsgi_logger));

memcpy(copy_of_chosen_logger, chosen_logger, sizeof(struct uwsgi_logger));

chosen_logger = copy_of_chosen_logger;

chosen_logger->id = id;

chosen_logger->next = NULL;

if (colon) {

chosen_logger->arg = colon + 1;

// check for empty string

if (*chosen_logger->arg == 0) {

chosen_logger->arg = NULL;

}

*colon = ':';

}

return chosen_logger;

}

void uwsgi_setup_log_master(void) {

struct uwsgi_string_list *usl = uwsgi.requested_logger;

while (usl) {

struct uwsgi_logger *chosen_logger = setup_chosen_logger(usl);

uwsgi_append_logger(chosen_logger);

usl = usl->next;

}

usl = uwsgi.requested_req_logger;

while (usl) {

struct uwsgi_logger *chosen_logger = setup_chosen_logger(usl);

uwsgi_append_req_logger(chosen_logger);

usl = usl->next;

}

#if defined(UWSGI_PCRE) || defined(UWSGI_PCRE2)

// set logger by its id

struct uwsgi_regexp_list *url = uwsgi.log_route;

while (url) {

url->custom_ptr = uwsgi_get_logger_from_id(url->custom_str);

url = url->next;

}

url = uwsgi.log_req_route;

while (url) {

url->custom_ptr = uwsgi_get_logger_from_id(url->custom_str);

url = url->next;

}

#endif

uwsgi.original_log_fd = dup(1);

create_logpipe();

}

struct uwsgi_logvar *uwsgi_logvar_get(struct wsgi_request *wsgi_req, char *key, uint8_t keylen) {

struct uwsgi_logvar *lv = wsgi_req->logvars;

while (lv) {

if (!uwsgi_strncmp(key, keylen, lv->key, lv->keylen)) {

return lv;

}

lv = lv->next;

}

return NULL;

}

void uwsgi_logvar_add(struct wsgi_request *wsgi_req, char *key, uint8_t keylen, char *val, uint8_t vallen) {

struct uwsgi_logvar *lv = uwsgi_logvar_get(wsgi_req, key, keylen);

if (lv) {

memcpy(lv->val, val, vallen);

lv->vallen = vallen;

return;

}

// add a new log object

lv = wsgi_req->logvars;

if (lv) {

while (lv) {

if (!lv->next) {

lv->next = uwsgi_malloc(sizeof(struct uwsgi_logvar));

lv = lv->next;

break;

}

lv = lv->next;

}

}

else {

lv = uwsgi_malloc(sizeof(struct uwsgi_logvar));

wsgi_req->logvars = lv;

}

memcpy(lv->key, key, keylen);

lv->keylen = keylen;

memcpy(lv->val, val, vallen);

lv->vallen = vallen;

lv->next = NULL;

}

void uwsgi_check_logrotate(void) {

int need_rotation = 0;

int need_reopen = 0;

off_t logsize;

int logfd;

struct stat logstat;

if (uwsgi.log_master) {

logfd = uwsgi.original_log_fd;

}

else {

logfd = 2;

}

if (fstat(logfd, &logstat) < 0) {

uwsgi_error("uwsgi_check_logrotate()/fstat()");

return;

}

if (S_ISFIFO(logstat.st_mode) || S_ISSOCK(logstat.st_mode)) {

return;

}

logsize = lseek(logfd, 0, SEEK_CUR);

if (logsize < 0) {

uwsgi_error("uwsgi_check_logrotate()/lseek()");

return;

}

uwsgi.shared->logsize = logsize;

if (uwsgi.log_maxsize > 0 && (uint64_t) uwsgi.shared->logsize > uwsgi.log_maxsize) {

need_rotation = 1;

}

if (uwsgi_check_touches(uwsgi.touch_logrotate)) {

need_rotation = 1;

}

if (uwsgi_check_touches(uwsgi.touch_logreopen)) {

need_reopen = 1;

}

if (need_rotation) {

uwsgi_log_rotate();

}

else if (need_reopen) {

uwsgi_log_reopen();

}

}

void uwsgi_log_do_rotate(char *logfile, char *rotatedfile, off_t logsize, int log_fd) {

int need_free = 0;

char *rot_name = rotatedfile;

if (rot_name == NULL) {

char *ts_str = uwsgi_num2str((int) uwsgi_now());

rot_name = uwsgi_concat3(logfile, ".", ts_str);

free(ts_str);

need_free = 1;

}

// this will be rawly written to the logfile

uwsgi_logfile_write("logsize: %llu, triggering rotation to %s...\n", (unsigned long long) logsize, rot_name);

if (rename(logfile, rot_name) == 0) {

// reopen logfile and dup'it, on dup2 error, exit(1)

int fd = open(logfile, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP);

if (fd < 0) {

// this will be written to the original file

uwsgi_error_open(logfile);

exit(1);

}

else {

if (dup2(fd, log_fd) < 0) {

// this could be lost :(

uwsgi_error("uwsgi_log_do_rotate()/dup2()");

exit(1);

}

close(fd);

}

}

else {

uwsgi_error("unable to rotate log: rename()");

}

if (need_free)

free(rot_name);

}

void uwsgi_log_rotate() {

if (!uwsgi.logfile)

return;

uwsgi_log_do_rotate(uwsgi.logfile, uwsgi.log_backupname, uwsgi.shared->logsize, uwsgi.original_log_fd);

}

void uwsgi_log_reopen() {

char message[1024];

if (!uwsgi.logfile) return;

int ret = snprintf(message, 1024, "[%d] logsize: %llu, triggering log-reopen...\n", (int) uwsgi_now(), (unsigned long long) uwsgi.shared->logsize);

if (ret > 0 && ret < 1024) {

if (write(uwsgi.original_log_fd, message, ret) != ret) {

// very probably this will never be printed

uwsgi_error("write()");

}

}

// reopen logfile;

close(uwsgi.original_log_fd);

uwsgi.original_log_fd = open(uwsgi.logfile, O_RDWR | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR | S_IRGRP);

if (uwsgi.original_log_fd < 0) {

uwsgi_error_open(uwsgi.logfile);

grace_them_all(0);

return;

}

ret = snprintf(message, 1024, "[%d] %s reopened.\n", (int) uwsgi_now(), uwsgi.logfile);

if (ret > 0 && ret < 1024) {

if (write(uwsgi.original_log_fd, message, ret) != ret) {

// very probably this will never be printed

uwsgi_error("write()");

}

}

uwsgi.shared->logsize = lseek(uwsgi.original_log_fd, 0, SEEK_CUR);

}

void log_request(struct wsgi_request *wsgi_req) {

int log_it = uwsgi.logging_options.enabled;

if (wsgi_req->do_not_log)

return;

if (wsgi_req->log_this) {

goto logit;

}

/* conditional logging */

if (uwsgi.logging_options.zero && wsgi_req->response_size == 0) {

goto logit;

}

if (uwsgi.logging_options.slow && (uint32_t) wsgi_req_time >= uwsgi.logging_options.slow) {

goto logit;

}

if (uwsgi.logging_options._4xx && (wsgi_req->status >= 400 && wsgi_req->status <= 499)) {

goto logit;

}

if (uwsgi.logging_options._5xx && (wsgi_req->status >= 500 && wsgi_req->status <= 599)) {

goto logit;

}

if (uwsgi.logging_options.big && (wsgi_req->response_size >= uwsgi.logging_options.big)) {

goto logit;

}

if (uwsgi.logging_options.sendfile && wsgi_req->via == UWSGI_VIA_SENDFILE) {

goto logit;

}

if (uwsgi.logging_options.ioerror && wsgi_req->read_errors > 0 && wsgi_req->write_errors > 0) {

goto logit;

}

if (!log_it)

return;

logit:

uwsgi.logit(wsgi_req);

}

void uwsgi_logit_simple(struct wsgi_request *wsgi_req) {

// optimize this (please)

char time_request[26];

int rlen;

int app_req = -1;

char *msg2 = " ";

char *via = msg2;

char mempkt[4096];

char logpkt[4096];

struct iovec logvec[4];

int logvecpos = 0;

const char *msecs = "msecs";

const char *micros = "micros";

char *tsize = (char *) msecs;

char *msg1 = " via sendfile() ";

char *msg3 = " via route() ";

char *msg4 = " via offload() ";

struct uwsgi_app *wi;

if (wsgi_req->app_id >= 0) {

wi = &uwsgi_apps[wsgi_req->app_id];

if (wi->requests > 0) {

app_req = wi->requests;

}

}

// mark requests via (sendfile, route, offload...)

switch(wsgi_req->via) {

case UWSGI_VIA_SENDFILE:

via = msg1;

break;

case UWSGI_VIA_ROUTE:

via = msg3;

break;

case UWSGI_VIA_OFFLOAD:

via = msg4;

break;

default:

break;

}

#if defined(__sun__) && !defined(__clang__)

ctime_r((const time_t *) &wsgi_req->start_of_request_in_sec, time_request, 26);

#else

ctime_r((const time_t *) &wsgi_req->start_of_request_in_sec, time_request);

#endif

uint64_t rt = 0;

// avoid overflow on clock instability (#1489)

if (wsgi_req->end_of_request > wsgi_req->start_of_request)

rt = wsgi_req->end_of_request - wsgi_req->start_of_request;

if (uwsgi.log_micros) {

tsize = (char *) micros;

}

else {

rt /= 1000;

}

if (uwsgi.vhost) {

logvec[logvecpos].iov_base = wsgi_req->host;

logvec[logvecpos].iov_len = wsgi_req->host_len;

logvecpos++;

logvec[logvecpos].iov_base = " ";

logvec[logvecpos].iov_len = 1;

logvecpos++;

}

if (uwsgi.logging_options.memory_report) {

rlen = snprintf(mempkt, 4096, "{address space usage: %llu bytes/%lluMB} {rss usage: %llu bytes/%lluMB} ",

(unsigned long long) uwsgi.workers[uwsgi.mywid].vsz_size,

(unsigned long long) uwsgi.workers[uwsgi.mywid].vsz_size / 1024 / 1024,

(unsigned long long) uwsgi.workers[uwsgi.mywid].rss_size,

(unsigned long long) uwsgi.workers[uwsgi.mywid].rss_size / 1024 / 1024);

if (uwsgi.logging_options.memory_report == 2) {

rlen += snprintf(mempkt + rlen, 4096 - rlen, "{uss usage: %llu bytes/%lluMB} {pss usage: %llu bytes/%lluMB} ",

(unsigned long long) uwsgi.workers[uwsgi.mywid].uss_size,

(unsigned long long) uwsgi.workers[uwsgi.mywid].uss_size / 1024 / 1024,

(unsigned long long) uwsgi.workers[uwsgi.mywid].pss_size,

(unsigned long long) uwsgi.workers[uwsgi.mywid].pss_size / 1024 / 1024);

}

logvec[logvecpos].iov_base = mempkt;

logvec[logvecpos].iov_len = rlen;

logvecpos++;

}

char *remote_user = wsgi_req->remote_user == NULL ? "" : wsgi_req->remote_user;

rlen = snprintf(logpkt, 4096, "[pid: %d|app: %d|req: %d/%llu] %.*s (%.*s) {%d vars in %llu bytes} [%.*s] %.*s %.*s => generated %llu bytes in %llu %s%s(%.*s %d) %d headers in %llu bytes (%d switches on core %d)\n", (int) uwsgi.mypid, wsgi_req->app_id, app_req, (unsigned long long) uwsgi.workers[0].requests, wsgi_req->remote_addr_len, wsgi_req->remote_addr, wsgi_req->remote_user_len, remote_user, wsgi_req->var_cnt, (unsigned long long) wsgi_req->len,

24, time_request, wsgi_req->method_len, wsgi_req->method, wsgi_req->uri_len, wsgi_req->uri, (unsigned long long) wsgi_req->response_size, (unsigned long long) rt, tsize, via, wsgi_req->protocol_len, wsgi_req->protocol, wsgi_req->status, wsgi_req->header_cnt, (unsigned long long) wsgi_req->headers_size, wsgi_req->switches, wsgi_req->async_id);

// not enough space for logging the request, just log a (safe) minimal message

if (rlen > 4096) {

rlen = snprintf(logpkt, 4096, "[pid: %d|app: %d|req: %d/%llu] 0.0.0.0 () {%d vars in %llu bytes} [%.*s] - - => generated %llu bytes in %llu %s%s(- %d) %d headers in %llu bytes (%d switches on core %d)\n", (int) uwsgi.mypid, wsgi_req->app_id, app_req, (unsigned long long) uwsgi.workers[0].requests, wsgi_req->var_cnt, (unsigned long long) wsgi_req->len,

24, time_request, (unsigned long long) wsgi_req->response_size, (unsigned long long) rt, tsize, via, wsgi_req->status, wsgi_req->header_cnt, (unsigned long long) wsgi_req->headers_size, wsgi_req->switches, wsgi_req->async_id);

// argh, last resort, truncate it

if (rlen > 4096) {

rlen = 4096;

}

}

logvec[logvecpos].iov_base = logpkt;

logvec[logvecpos].iov_len = rlen;

// do not check for errors

rlen = writev(uwsgi.req_log_fd, logvec, logvecpos + 1);

}

void get_memusage(uint64_t * rss, uint64_t * vsz) {

#ifdef UNBIT

uint64_t ret[2];

ret[0] = 0; ret[1] = 0;

syscall(358, ret);

*vsz = ret[0];

*rss = ret[1] * uwsgi.page_size;

#elif defined(__linux__)

FILE *procfile;

int i;

procfile = fopen("/proc/self/stat", "r");

if (procfile) {

i = fscanf(procfile, "%*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %llu %llu", (unsigned long long *) vsz, (unsigned long long *) rss);

if (i != 2) {

uwsgi_log("warning: invalid record in /proc/self/stat\n");

} else {

*rss = *rss * uwsgi.page_size;

}

fclose(procfile);

}

#elif defined(__CYGWIN__)

// same as Linux but rss is not in pages...

FILE *procfile;

int i;

procfile = fopen("/proc/self/stat", "r");

if (procfile) {

i = fscanf(procfile, "%*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %llu %llu", (unsigned long long *) vsz, (unsigned long long *) rss);

if (i != 2) {

uwsgi_log("warning: invalid record in /proc/self/stat\n");

}

fclose(procfile);

}

#elif defined (__sun__)

psinfo_t info;

int procfd;

procfd = open("/proc/self/psinfo", O_RDONLY);

if (procfd >= 0) {

if (read(procfd, (char *) &info, sizeof(info)) > 0) {

*rss = (uint64_t) info.pr_rssize * 1024;

*vsz = (uint64_t) info.pr_size * 1024;

}

close(procfd);

}

#elif defined(__APPLE__)

/* darwin documentation says that the value are in pages, but they are bytes !!! */

struct task_basic_info t_info;

mach_msg_type_number_t t_size = sizeof(struct task_basic_info);

if (task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t) & t_info, &t_size) == KERN_SUCCESS) {

*rss = t_info.resident_size;

*vsz = t_info.virtual_size;

}

#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__DragonFly__) || defined(__OpenBSD__)

kvm_t *kv;

int cnt;

#if defined(__FreeBSD__)

kv = kvm_open(NULL, "/dev/null", NULL, O_RDONLY, NULL);

#elif defined(__NetBSD__) || defined(__OpenBSD__)

kv = kvm_open(NULL, NULL, NULL, KVM_NO_FILES, NULL);

#else

kv = kvm_open(NULL, NULL, NULL, O_RDONLY, NULL);

#endif

if (kv) {

#if defined(__FreeBSD__) || defined(__DragonFly__)

struct kinfo_proc *kproc;

kproc = kvm_getprocs(kv, KERN_PROC_PID, uwsgi.mypid, &cnt);

if (kproc && cnt > 0) {

#if defined(__FreeBSD__)

*vsz = kproc->ki_size;

*rss = kproc->ki_rssize * uwsgi.page_size;

#elif defined(__DragonFly__)

*vsz = kproc->kp_vm_map_size;

*rss = kproc->kp_vm_rssize * uwsgi.page_size;

#endif

}

#elif defined(UWSGI_NEW_OPENBSD)

struct kinfo_proc *kproc;

kproc = kvm_getprocs(kv, KERN_PROC_PID, uwsgi.mypid, sizeof(struct kinfo_proc), &cnt);

if (kproc && cnt > 0) {

*vsz = (kproc->p_vm_dsize + kproc->p_vm_ssize + kproc->p_vm_tsize) * uwsgi.page_size;

*rss = kproc->p_vm_rssize * uwsgi.page_size;

}

#elif defined(__NetBSD__) || defined(__OpenBSD__)

struct kinfo_proc2 *kproc2;

kproc2 = kvm_getproc2(kv, KERN_PROC_PID, uwsgi.mypid, sizeof(struct kinfo_proc2), &cnt);

if (kproc2 && cnt > 0) {

#ifdef __OpenBSD__

*vsz = (kproc2->p_vm_dsize + kproc2->p_vm_ssize + kproc2->p_vm_tsize) * uwsgi.page_size;

#else

*vsz = kproc2->p_vm_msize * uwsgi.page_size;

#endif

*rss = kproc2->p_vm_rssize * uwsgi.page_size;

}

#endif

kvm_close(kv);

}

#elif defined(__HAIKU__)

area_info ai;

int32 cookie;

*vsz = 0;

*rss = 0;

while (get_next_area_info(0, &cookie, &ai) == B_OK) {

*vsz += ai.ram_size;

if ((ai.protection & B_WRITE_AREA) != 0) {

*rss += ai.ram_size;

}

}

#endif

}

#ifdef __linux__

void get_memusage_extra(uint64_t * uss, uint64_t * pss) {

FILE *file = fopen("/proc/self/smaps", "r");

char line [BUFSIZ];

while (fgets(line, sizeof line, file)) {

char substr[32];

int n;

if (sscanf(line, "%31[^:]: %d", substr, &n) == 2)

{

if (strcmp(substr, "Private_Clean") == 0)

*uss += n * 1024;

else if (strcmp(substr, "Private_Dirty") == 0)

*uss += n * 1024;

else if (strcmp(substr, "Pss") == 0)

*pss += n * 1024;

}

}

fclose(file);

}

#endif

void uwsgi_register_logger(char *name, ssize_t(*func) (struct uwsgi_logger *, char *, size_t)) {

struct uwsgi_logger *ul = uwsgi.loggers, *old_ul;

if (!ul) {

uwsgi.loggers = uwsgi_malloc(sizeof(struct uwsgi_logger));

ul = uwsgi.loggers;

}

else {

while (ul) {

old_ul = ul;

ul = ul->next;

}

ul = uwsgi_malloc(sizeof(struct uwsgi_logger));

old_ul->next = ul;

}

ul->name = name;

ul->func = func;

ul->next = NULL;

ul->configured = 0;

ul->fd = -1;

ul->data = NULL;

ul->buf = NULL;

#ifdef UWSGI_DEBUG

uwsgi_log("[uwsgi-logger] registered \"%s\"\n", ul->name);

#endif

}

void uwsgi_append_logger(struct uwsgi_logger *ul) {

if (!uwsgi.choosen_logger) {

uwsgi.choosen_logger = ul;

return;

}

struct uwsgi_logger *ucl = uwsgi.choosen_logger;

while (ucl) {

if (!ucl->next) {

ucl->next = ul;

return;

}

ucl = ucl->next;

}

}

void uwsgi_append_req_logger(struct uwsgi_logger *ul) {

if (!uwsgi.choosen_req_logger) {

uwsgi.choosen_req_logger = ul;

return;

}

struct uwsgi_logger *ucl = uwsgi.choosen_req_logger;

while (ucl) {

if (!ucl->next) {

ucl->next = ul;

return;

}

ucl = ucl->next;

}

}

struct uwsgi_logger *uwsgi_get_logger(char *name) {

struct uwsgi_logger *ul = uwsgi.loggers;

while (ul) {

if (!strcmp(ul->name, name)) {

return ul;

}

ul = ul->next;

}

return NULL;

}

struct uwsgi_logger *uwsgi_get_logger_from_id(char *id) {

struct uwsgi_logger *ul = uwsgi.choosen_logger;

while (ul) {

if (ul->id && !strcmp(ul->id, id)) {

return ul;

}

ul = ul->next;

}

return NULL;

}

void uwsgi_logit_lf(struct wsgi_request *wsgi_req) {

struct uwsgi_logchunk *logchunk = uwsgi.logchunks;

ssize_t rlen = 0;

const char *empty_var = "-";