source: trunk/coverage.c @ 13

Last change on this file since 13 was 13, checked in by moo, 9 years ago

fix build on win32,shared

File size: 9.6 KB
Line 
1#include <stdio.h>
2#include "xcache.h"
3#include "ext/standard/flock_compat.h"
4#ifdef HAVE_SYS_FILE_H
5#   include <sys/file.h>
6#endif
7#include <sys/types.h>
8#include <sys/stat.h>
9#include <fcntl.h>
10
11#include "stack.h"
12#include "xcache_globals.h"
13#include "coverage.h"
14#include "utils.h"
15typedef HashTable *coverage_t;
16#define PCOV_HEADER_MAGIC 0x564f4350
17
18char *xc_coveragedump_dir = NULL;
19static zend_compile_file_t *origin_compile_file;
20
21#undef DEBUG
22/* dumper */
23static void xc_destroy_coverage(void *pDest) /* {{{ */
24{
25    coverage_t cov = *(coverage_t*) pDest;
26#ifdef DEBUG
27    fprintf(stderr, "destroy %p\n", cov);
28#endif
29    zend_hash_destroy(cov);
30    efree(cov);
31}
32/* }}} */
33void xcache_mkdirs_ex(char *root, int rootlen, char *path, int pathlen TSRMLS_DC) /* {{{ */
34{
35    char *fullpath;
36    struct stat st;
37
38#ifdef DEBUG
39    fprintf(stderr, "mkdirs %s %d %s %d\n", root, rootlen, path, pathlen);
40#endif
41    fullpath = do_alloca(rootlen + pathlen + 1);
42    memcpy(fullpath, root, rootlen);
43    memcpy(fullpath + rootlen, path, pathlen);
44    fullpath[rootlen + pathlen] = '\0';
45
46    if (stat(fullpath, &st) != 0) {
47        char *chr;
48
49        chr = strrchr(path, PHP_DIR_SEPARATOR);
50        if (chr && chr != path) {
51            *chr = '\0';
52            xcache_mkdirs_ex(root, rootlen, path, chr - path TSRMLS_CC);
53            *chr = PHP_DIR_SEPARATOR;
54        }
55#ifdef DEBUG
56        fprintf(stderr, "mkdir %s\n", fullpath);
57#endif
58        php_stream_mkdir(fullpath, 0700, REPORT_ERRORS, NULL);
59    }
60    free_alloca(fullpath);
61}
62/* }}} */
63static void xc_coverage_save_cov(char *srcfile, char *outfilename, coverage_t cov TSRMLS_DC) /* {{{ */
64{
65    long *buf = NULL, *p;
66    long covlines, *phits;
67    int fd = -1;
68    int size;
69    int newfile;
70    struct stat srcstat, outstat;
71    HashPosition pos;
72    char *contents = NULL;
73    long len;
74
75    if (stat(srcfile, &srcstat) != 0) {
76        return;
77    }
78
79    newfile = 0;
80    if (stat(outfilename, &outstat) != 0) {
81        newfile = 1;
82    }
83    else {
84        if (srcstat.st_mtime > outstat.st_mtime) {
85            newfile = 1;
86        }
87    }
88
89    fd = open(outfilename, O_RDWR | O_CREAT, 0600);
90    if (fd < 0) {
91        char *chr;
92        chr = strrchr(srcfile, PHP_DIR_SEPARATOR);
93        if (chr) {
94            *chr = '\0';
95            xcache_mkdirs_ex(xc_coveragedump_dir, strlen(xc_coveragedump_dir), srcfile, chr - srcfile TSRMLS_CC);
96            *chr = PHP_DIR_SEPARATOR;
97        }
98        fd = open(outfilename, O_RDWR | O_CREAT, 0600);
99        if (fd < 0) {
100            goto bailout;
101        }
102    }
103    if (flock(fd, LOCK_EX) != SUCCESS) {
104        goto bailout;
105    }
106
107    if (newfile) {
108#ifdef DEBUG
109        fprintf(stderr, "new file\n");
110#endif
111    }
112    else if (outstat.st_size) {
113        len = outstat.st_size;
114        contents = emalloc(len);
115        if (read(fd, (void *) contents, len) != len) {
116            goto bailout;
117        }
118#ifdef DEBUG
119        fprintf(stderr, "oldsize %d\n", (int) len);
120#endif
121        do {
122            p = (long *) contents;
123            len -= sizeof(long);
124            if (len < 0) {
125                break;
126            }
127            if (*p++ != PCOV_HEADER_MAGIC) {
128#ifdef DEBUG
129                fprintf(stderr, "wrong magic in file %s\n", outfilename);
130#endif
131                break;
132            }
133
134            p += 2; /* skip covliens */
135            len -= sizeof(long) * 2;
136            if (len < 0) {
137                break;
138            }
139
140            for (; len >= sizeof(long) * 2; len -= sizeof(long) * 2, p += 2) {
141                if (zend_hash_index_find(cov, p[0], (void**)&phits) == SUCCESS) {
142                    if (p[1] <= 0) {
143                        /* already marked */
144                        continue;
145                    }
146                    if (*phits > 0) {
147                        p[1] += *phits;
148                    }
149                }
150                zend_hash_index_update(cov, p[0], &p[1], sizeof(p[1]), NULL);
151            }
152        } while (0);
153        efree(contents);
154        contents = NULL;
155    }
156
157
158    /* serialize */
159    size = (zend_hash_num_elements(cov) + 1) * sizeof(long) * 2 + sizeof(long);
160    p = buf = emalloc(size);
161    *p++ = PCOV_HEADER_MAGIC;
162    p += 2; /* for covlines */
163    covlines = 0;
164
165    zend_hash_internal_pointer_reset_ex(cov, &pos);
166    while (zend_hash_get_current_data_ex(cov, (void**)&phits, &pos) == SUCCESS) {
167        *p++ = pos->h;
168        if (*phits <= 0) {
169            *p++ = 0;
170        }
171        else {
172            *p++ = *phits;
173            covlines ++;
174        }
175        zend_hash_move_forward_ex(cov, &pos);
176    }
177    p = buf + 1;
178    p[0] = 0;
179    p[1] = covlines;
180
181    ftruncate(fd, 0);
182    lseek(fd, 0, SEEK_SET);
183    write(fd, (char *) buf, size);
184
185bailout:
186    if (contents) efree(contents);
187    if (fd >= 0) close(fd);
188    if (buf) efree(buf);
189}
190/* }}} */
191void xc_coverage_request_init(TSRMLS_D) /* {{{ */
192{
193    if (XG(coveragedumper)) {
194        XG(coverages) = emalloc(sizeof(HashTable));
195        zend_hash_init(XG(coverages), 0, NULL, xc_destroy_coverage, 0);
196    }
197}
198/* }}} */
199void xc_coverage_request_shutdown(TSRMLS_D) /* {{{ */
200{
201    coverage_t *pcov;
202    zstr s;
203    char *outfilename;
204    int dumpdir_len, outfilelen, size, alloc_len = 0;
205
206    if (!XG(coverages)) {
207        return;
208    }
209    if (XG(coveragedumper)) {   
210        dumpdir_len = strlen(xc_coveragedump_dir);
211        alloc_len = dumpdir_len + 1 + 128;
212        outfilename = emalloc(alloc_len);
213        strcpy(outfilename, xc_coveragedump_dir);
214
215        zend_hash_internal_pointer_reset(XG(coverages));
216        while (zend_hash_get_current_data(XG(coverages), (void **) &pcov) == SUCCESS) {
217            zend_hash_get_current_key_ex(XG(coverages), &s, &size, NULL, 0, NULL);
218            outfilelen = dumpdir_len + size + 5;
219            if (alloc_len < outfilelen) {
220                alloc_len = outfilelen + 128;
221                outfilename = erealloc(outfilename, alloc_len);
222            }
223            strcpy(outfilename + dumpdir_len, ZSTR_S(s));
224            strcpy(outfilename + dumpdir_len + size - 1, ".pcov");
225
226#ifdef DEBUG
227            fprintf(stderr, "outfilename %s\n", outfilename);
228#endif
229            xc_coverage_save_cov(ZSTR_S(s), outfilename, *pcov TSRMLS_CC);
230            zend_hash_move_forward(XG(coverages));
231        }
232    }
233
234    zend_hash_destroy(XG(coverages));
235    efree(XG(coverages));
236    XG(coverages) = NULL;
237}
238/* }}} */
239
240/* helper func to store hits into coverages */
241static coverage_t xc_coverage_get(char *filename TSRMLS_DC) /* {{{ */
242{
243    int len = strlen(filename) + 1;
244    coverage_t cov, *pcov;
245
246    if (zend_hash_find(XG(coverages), filename, len, (void **) &pcov) == SUCCESS) {
247#ifdef DEBUG
248        fprintf(stderr, "got coverage %s %p\n", filename, *pcov);
249#endif
250        return *pcov;
251    }
252    else {
253        cov = emalloc(sizeof(HashTable));
254        zend_hash_init(cov, 0, NULL, NULL, 0);
255        zend_hash_add(XG(coverages), filename, len, (void **) &cov, sizeof(cov), NULL);
256#ifdef DEBUG
257        fprintf(stderr, "new coverage %s %p\n", filename, cov);
258#endif
259        return cov;
260    }
261}
262/* }}} */
263static void xc_coverage_add_hits(HashTable *cov, long line, long hits TSRMLS_DC) /* {{{ */
264{
265    long *poldhits;
266
267    if (line == 0) {
268        return;
269    }
270    if (zend_hash_index_find(cov, line, (void**)&poldhits) == SUCCESS) {
271        if (hits == -1) {
272            /* already marked */
273            return;
274        }
275        if (*poldhits != -1) {
276            hits += *poldhits;
277        }
278    }
279    zend_hash_index_update(cov, line, &hits, sizeof(hits), NULL);
280}
281/* }}} */
282
283static int xc_coverage_get_op_array_size_no_tail(zend_op_array *op_array) /* {{{ */
284{
285    zend_uint size;
286
287    size = op_array->size;
288#ifdef ZEND_ENGINE_2
289    if (op_array->opcodes[size - 1].opcode == ZEND_HANDLE_EXCEPTION) {
290        size --;
291#endif
292        if (op_array->opcodes[size - 1].opcode == ZEND_RETURN) {
293            size --;
294            /* it's not real php statement */
295            if (op_array->opcodes[size - 1].opcode == ZEND_EXT_STMT) {
296                size --;
297            }
298        }   
299#ifdef ZEND_ENGINE_2
300    }
301#endif
302    return size;
303}
304/* }}} */
305
306/* prefill */
307static int xc_coverage_init_op_array(zend_op_array *op_array TSRMLS_DC) /* {{{ */
308{
309    zend_uint size;
310    coverage_t cov;
311    zend_uint i;
312
313    if (op_array->type != ZEND_USER_FUNCTION) {
314        return 0;
315    }
316
317    size = xc_coverage_get_op_array_size_no_tail(op_array);
318    cov = xc_coverage_get(op_array->filename TSRMLS_CC);
319    for (i = 0; i < size; i ++) {
320        switch (op_array->opcodes[i].opcode) {
321            case ZEND_EXT_STMT:
322#if 0
323            case ZEND_EXT_FCALL_BEGIN:
324            case ZEND_EXT_FCALL_END:
325#endif
326                xc_coverage_add_hits(cov, op_array->opcodes[i].lineno, -1 TSRMLS_CC);
327                break;
328        }
329    }
330    return 0;
331}
332/* }}} */
333static void xc_coverage_init_compile_result(zend_op_array *op_array TSRMLS_DC) /* {{{ */
334{
335    xc_compile_result_t cr;
336
337    xc_compile_result_init_cur(&cr, op_array TSRMLS_CC);
338    xc_apply_op_array(&cr, (apply_func_t) xc_coverage_init_op_array TSRMLS_CC);
339    xc_compile_result_free(&cr);
340}
341/* }}} */
342static zend_op_array *xc_compile_file_for_coverage(zend_file_handle *h, int type TSRMLS_DC) /* {{{ */
343{
344    zend_op_array *op_array;
345
346    op_array = origin_compile_file(h, type TSRMLS_CC);
347    if (XG(coveragedumper) && XG(coverages)) {
348        xc_coverage_init_compile_result(op_array TSRMLS_CC);
349    }
350    return op_array;
351}
352/* }}} */
353
354/* hits */
355void xc_coverage_handle_ext_stmt(zend_op_array *op_array, zend_uchar op) /* {{{ */
356{
357    TSRMLS_FETCH();
358
359    if (XG(coveragedumper) && XG(coverages)) {
360        int size = xc_coverage_get_op_array_size_no_tail(op_array);
361        int oplineno = (*EG(opline_ptr)) - op_array->opcodes;
362        if (oplineno < size) {
363            xc_coverage_add_hits(xc_coverage_get(op_array->filename TSRMLS_CC), (*EG(opline_ptr))->lineno, 1 TSRMLS_CC);
364        }
365    }
366}
367/* }}} */
368
369/* init/destroy */
370int xc_coverage_init(int module_number TSRMLS_DC) /* {{{ */
371{
372    if (xc_coveragedump_dir) {
373        int len = strlen(xc_coveragedump_dir);
374        if (len) {
375            if (xc_coveragedump_dir[len - 1] == '/') {
376                xc_coveragedump_dir[len - 1] = '\0';
377            }
378        }
379    }
380    if (xc_coveragedump_dir && xc_coveragedump_dir[0]) {
381        origin_compile_file = zend_compile_file;
382        zend_compile_file = xc_compile_file_for_coverage;
383        CG(extended_info) = 1;
384    }
385    return SUCCESS;
386}
387/* }}} */
388void xc_coverage_destroy() /* {{{ */
389{
390    if (origin_compile_file == xc_compile_file_for_coverage) {
391        zend_compile_file = origin_compile_file;
392    }
393    if (xc_coveragedump_dir) {
394        pefree(xc_coveragedump_dir, 1);
395        xc_coveragedump_dir = NULL;
396    }
397}
398/* }}} */
399
400/* user api */
401PHP_FUNCTION(xcache_coverage_decode) /* {{{ */
402{
403    char *str;
404    int len;
405    long *p;
406
407    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &len) == FAILURE) {
408        return;
409    }
410
411    array_init(return_value);
412
413    p = (long*) str;
414    len -= sizeof(long);
415    if (len < 0) {
416        return;
417    }
418    if (*p++ != PCOV_HEADER_MAGIC) {
419#ifdef DEBUG
420        fprintf(stderr, "wrong magic in xcache_coverage_decode");
421#endif
422        return;
423    }
424
425    for (; len >= sizeof(long) * 2; len -= sizeof(long) * 2, p += 2) {
426        add_index_long(return_value, p[0], p[1]);
427    }
428}
429/* }}} */
430
Note: See TracBrowser for help on using the repository browser.