Changeset 662 for trunk/xcache.c


Ignore:
Timestamp:
2009-08-03T10:15:53+02:00 (5 years ago)
Author:
moo
Message:

back patch __FILE and __DIR on cache restore

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/xcache.c

    r661 r662  
    3737#include "opcode_spec.h" 
    3838#include "utils.h" 
     39 
     40#ifndef ZEND_ENGINE_2_3 
     41ZEND_API size_t zend_dirname(char *path, size_t len) 
     42{ 
     43    php_dirname(path, len); 
     44    return strlen(path); 
     45} 
     46#endif 
    3947 
    4048#define VAR_ENTRY_EXPIRED(pentry) ((pentry)->ttl && XG(request_time) > pentry->ctime + (pentry)->ttl) 
     
    10051013    { 
    10061014        /* hash on filename, let's expand it to real path */ 
     1015        /* FIXME */ 
    10071016        filename = expand_filepath(filename, opened_path_buffer TSRMLS_CC); 
    10081017        if (filename == NULL) { 
     
    11081117/* }}} */ 
    11091118#endif 
     1119 
     1120/* {{{ Constant Usage */ 
     1121#define xcache_op1_is_file 1 
     1122#define xcache_op1_is_dir  2 
     1123#define xcache_op2_is_file 4 
     1124#define xcache_op2_is_dir  8 
     1125typedef struct { 
     1126    zend_bool filepath_used; 
     1127    zend_bool dirpath_used; 
     1128    zend_bool ufilepath_used; 
     1129    zend_bool udirpath_used; 
     1130} xc_const_usage_t; 
     1131/* }}} */ 
     1132static void xc_collect_op_array_info(xc_entry_data_php_t *php, xc_const_usage_t *usage, xc_op_array_info_t *op_array_info, zend_op_array *op_array TSRMLS_DC) /* {{{ */ 
     1133{ 
     1134    int oplineno; 
     1135    xc_vector_t vector_int; 
     1136 
     1137    xc_vector_init(int, &vector_int); 
     1138 
     1139#define XCACHE_CHECK_OP(type, op) \ 
     1140    if (zend_binary_strcmp(Z_STRVAL(opline->op.u.constant), Z_STRLEN(opline->op.u.constant), php->type##path, php->type##path_len) == 0) { \ 
     1141        usage->type##path_used = 1; \ 
     1142        oplineinfo |= xcache_##op##_is_##type; \ 
     1143    } 
     1144 
     1145#define XCACHE_U_CHECK_OP(type, op) \ 
     1146    if (zend_u_##binary_strcmp(Z_USTRVAL(opline->op.u.constant), Z_USTRLEN(opline->op.u.constant), php->u##type##path, php->u##type##path_len) == 0) { \ 
     1147        usage->u##type##path_used = 1; \ 
     1148        oplineinfo |= xcache_##op##_is_##type; \ 
     1149    } 
     1150 
     1151    for (oplineno = 0; oplineno < op_array->last; oplineno++) { 
     1152        zend_op *opline = &op_array->opcodes[oplineno]; 
     1153        int oplineinfo = 0; 
     1154        if (opline->op1.op_type == IS_CONST) { 
     1155            if (Z_TYPE(opline->op1.u.constant) == IS_STRING) { 
     1156                XCACHE_CHECK_OP(file, op1) 
     1157                else XCACHE_CHECK_OP(dir, op1) 
     1158            } 
     1159 
     1160#ifdef IS_UNICODE 
     1161            else if (Z_TYPE(opline->op1.u.constant) == IS_UNICODE) { 
     1162                XCACHE_U_CHECK_OP(file, op1) 
     1163                else XCACHE_U_CHECK_OP(dir, op1) 
     1164            } 
     1165#endif 
     1166        } 
     1167        if (opline->op2.op_type == IS_CONST) { 
     1168            if (Z_TYPE(opline->op2.u.constant) == IS_STRING) { 
     1169                XCACHE_CHECK_OP(file, op2) 
     1170                else XCACHE_CHECK_OP(dir, op2) 
     1171            } 
     1172 
     1173#ifdef IS_UNICODE 
     1174            else if (Z_TYPE(opline->op2.u.constant) == IS_UNICODE) { 
     1175                XCACHE_U_CHECK_OP(file, op2) 
     1176                else XCACHE_U_CHECK_OP(dir, op2) 
     1177            } 
     1178#endif 
     1179        } 
     1180        if (oplineinfo) { 
     1181            xc_vector_add(int, &vector_int, oplineno); 
     1182            xc_vector_add(int, &vector_int, oplineinfo); 
     1183        } 
     1184    } 
     1185 
     1186    op_array_info->oplineinfo_cnt = vector_int.cnt; 
     1187    op_array_info->oplineinfos    = xc_vector_detach(int, &vector_int); 
     1188    xc_vector_free(int, &vector_int); 
     1189} 
     1190/* }}} */ 
     1191void xc_fix_op_array_info(const xc_entry_data_php_t *php, zend_op_array *op_array, int copy, const xc_op_array_info_t *op_array_info TSRMLS_DC) /* {{{ */ 
     1192{ 
     1193    int i; 
     1194    if (!op_array_info->oplineinfo_cnt) { 
     1195        return; 
     1196    } 
     1197 
     1198    for (i = 0; i < op_array_info->oplineinfo_cnt; i += 2) { 
     1199        int oplineno = op_array_info->oplineinfos[i]; 
     1200        int oplineinfo = op_array_info->oplineinfos[i + 1]; 
     1201        zend_op *opline = &op_array->opcodes[oplineno]; 
     1202        if ((oplineinfo & xcache_op1_is_file)) { 
     1203            assert(opline->op1.op_type == IS_CONST); 
     1204            if (copy) { 
     1205                efree(Z_STRVAL(opline->op1.u.constant)); 
     1206            } 
     1207            if (Z_TYPE(opline->op1.u.constant) == IS_STRING) { 
     1208                assert(php->filepath); 
     1209                ZVAL_STRINGL(&opline->op1.u.constant, php->filepath, php->filepath_len, copy); 
     1210            } 
     1211#ifdef IS_UNICODE 
     1212            else if (Z_TYPE(opline->op1.u.constant) == IS_UNICODE) { 
     1213                assert(php->ufilepath); 
     1214                ZVAL_UNICODEL(&opline->op1.u.constant, php->ufilepath, php->ufilepath_len, copy); 
     1215            } 
     1216#endif 
     1217            else { 
     1218                assert(0); 
     1219            } 
     1220        } 
     1221        else if ((oplineinfo & xcache_op1_is_dir)) { 
     1222            assert(opline->op1.op_type == IS_CONST); 
     1223            if (copy) { 
     1224                efree(Z_STRVAL(opline->op1.u.constant)); 
     1225            } 
     1226            if (Z_TYPE(opline->op1.u.constant) == IS_STRING) { 
     1227                assert(php->dirpath); 
     1228                ZVAL_STRINGL(&opline->op1.u.constant, php->dirpath, php->dirpath_len, copy); 
     1229            } 
     1230#ifdef IS_UNICODE 
     1231            else if (Z_TYPE(opline->op1.u.constant) == IS_UNICODE) { 
     1232                assert(!php->udirpath); 
     1233                ZVAL_UNICODEL(&opline->op1.u.constant, php->udirpath, php->udirpath_len, copy); 
     1234            } 
     1235#endif 
     1236            else { 
     1237                assert(0); 
     1238            } 
     1239        } 
     1240 
     1241        if ((oplineinfo & xcache_op2_is_file)) { 
     1242            assert(opline->op2.op_type == IS_CONST); 
     1243            if (copy) { 
     1244                efree(Z_STRVAL(opline->op2.u.constant)); 
     1245            } 
     1246            if (Z_TYPE(opline->op2.u.constant) == IS_STRING) { 
     1247                assert(php->filepath); 
     1248                ZVAL_STRINGL(&opline->op2.u.constant, php->filepath, php->filepath_len, copy); 
     1249            } 
     1250#ifdef IS_UNICODE 
     1251            else if (Z_TYPE(opline->op2.u.constant) == IS_UNICODE) { 
     1252                assert(php->ufilepath); 
     1253                ZVAL_UNICODEL(&opline->op2.u.constant, php->ufilepath, php->ufilepath_len, copy); 
     1254            } 
     1255#endif 
     1256            else { 
     1257                assert(0); 
     1258            } 
     1259        } 
     1260        else if ((oplineinfo & xcache_op2_is_dir)) { 
     1261            assert(opline->op2.op_type == IS_CONST); 
     1262            if (copy) { 
     1263                efree(Z_STRVAL(opline->op2.u.constant)); 
     1264            } 
     1265            if (Z_TYPE(opline->op2.u.constant) == IS_STRING) { 
     1266                assert(!php->dirpath); 
     1267                ZVAL_STRINGL(&opline->op2.u.constant, php->dirpath, php->dirpath_len, copy); 
     1268            } 
     1269#ifdef IS_UNICODE 
     1270            else if (Z_TYPE(opline->op2.u.constant) == IS_UNICODE) { 
     1271                assert(!php->udirpath); 
     1272                ZVAL_UNICODEL(&opline->op2.u.constant, php->udirpath, php->udirpath_len, copy); 
     1273            } 
     1274#endif 
     1275            else { 
     1276                assert(0); 
     1277            } 
     1278        } 
     1279    } 
     1280} 
     1281/* }}} */ 
     1282static void xc_free_op_array_info(xc_op_array_info_t *op_array_info TSRMLS_DC) /* {{{ */ 
     1283{ 
     1284    if (op_array_info->oplineinfos) { 
     1285        efree(op_array_info->oplineinfos); 
     1286    } 
     1287} 
     1288/* }}} */ 
    11101289static void xc_free_php(xc_entry_data_php_t *php TSRMLS_DC) /* {{{ */ 
    11111290{ 
     1291    int i; 
     1292    if (php->classinfos) { 
     1293        for (i = 0; i < php->classinfo_cnt; i ++) { 
     1294            xc_classinfo_t *classinfo = &php->classinfos[i]; 
     1295            int j; 
     1296            for (j = 0; j < classinfo->methodinfo_cnt; j ++) { 
     1297                xc_free_op_array_info(&classinfo->methodinfos[j] TSRMLS_CC); 
     1298            } 
     1299 
     1300            if (classinfo->methodinfos) { 
     1301                efree(classinfo->methodinfos); 
     1302            } 
     1303        } 
     1304    } 
     1305    if (php->funcinfos) { 
     1306        for (i = 0; i < php->funcinfo_cnt; i ++) { 
     1307            xc_free_op_array_info(&php->funcinfos[i].op_array_info TSRMLS_CC); 
     1308        } 
     1309    } 
     1310    xc_free_op_array_info(&php->op_array_info TSRMLS_CC); 
     1311 
    11121312#define X_FREE(var) do {\ 
    11131313    if (php->var) { \ 
     
    11161316} while (0) 
    11171317 
     1318    X_FREE(dirpath); 
     1319#ifdef IS_UNICODE 
     1320    X_FREE(ufilepath); 
     1321    X_FREE(udirpath); 
     1322#endif 
     1323 
    11181324#ifdef ZEND_ENGINE_2_1 
    11191325    X_FREE(autoglobals); 
     
    11321338    int old_constinfo_cnt, old_funcinfo_cnt, old_classinfo_cnt; 
    11331339    zend_bool catched = 0; 
     1340    xc_const_usage_t const_usage; 
    11341341 
    11351342    /* {{{ compile */ 
     
    11621369    /* }}} */ 
    11631370    /* {{{ prepare */ 
     1371    zend_restore_compiled_filename(h->opened_path ? h->opened_path : h->filename TSRMLS_CC); 
    11641372    php->op_array      = op_array; 
    11651373 
     
    12061414#endif 
    12071415#undef X_ALLOC 
     1416    /* }}} */ 
     1417 
     1418    /* {{{ file/dir path init */ 
     1419    memset(&const_usage, 0, sizeof(const_usage)); 
     1420    php->filepath     = zend_get_compiled_filename(TSRMLS_C); 
     1421    php->filepath_len = strlen(php->filepath); 
     1422    php->dirpath      = estrndup(php->filepath, php->filepath_len); 
     1423    php->dirpath_len  = zend_dirname(php->dirpath, php->filepath_len); 
     1424#ifdef IS_UNICODE 
     1425    zend_string_to_unicode(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &php->ufilepath, &php->ufilepath_len, php->filepath, php->filepath_len TSRMLS_CC); 
     1426    zend_string_to_unicode(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &php->udirpath,  &php->udirpath_len,  php->dirpath,  php->dirpath_len TSRMLS_CC); 
     1427#endif 
    12081428    /* }}} */ 
    12091429    /* {{{ shallow copy, pointers only */ { 
     
    12421462        b = CG(class_table)->pListHead;    COPY_H(xc_classinfo_t, classinfos, classinfo_cnt, cest,     xc_cest_t); 
    12431463 
     1464        for (i = 0; i < php->classinfo_cnt; i ++) { 
     1465            xc_classinfo_t *classinfo = &php->classinfos[i]; 
     1466            zend_class_entry *ce = CestToCePtr(classinfo->cest); 
     1467            classinfo->methodinfo_cnt = ce->function_table.nTableSize; 
     1468            if (classinfo->methodinfo_cnt) { 
     1469                int j; 
     1470 
     1471                ECALLOC_N(classinfo->methodinfos, classinfo->methodinfo_cnt); 
     1472                if (!classinfo->methodinfos) { 
     1473                    goto err_alloc; 
     1474                } 
     1475 
     1476                for (j = 0, b = ce->function_table.pListHead; b; j ++, b = b->pListNext) { 
     1477                    xc_collect_op_array_info(php, &const_usage, &classinfo->methodinfos[j], (zend_op_array *) b->pData TSRMLS_CC); 
     1478                } 
     1479            } 
     1480            else { 
     1481                classinfo->methodinfos = NULL; 
     1482            } 
     1483        } 
     1484 
     1485        for (i = 0; i < php->funcinfo_cnt; i ++) { 
     1486            xc_collect_op_array_info(php, &const_usage, &php->funcinfos[i].op_array_info, (zend_op_array *) &php->funcinfos[i].func TSRMLS_CC); 
     1487        } 
     1488 
     1489        xc_collect_op_array_info(php, &const_usage, &php->op_array_info, php->op_array TSRMLS_CC); 
     1490 
    12441491#undef COPY_H 
    12451492 
     
    12711518    } 
    12721519    /* }}} */ 
     1520    /* {{{ file/dir path free unused */ 
     1521#define X_FREE_UNUSED(var) \ 
     1522    if (!const_usage.var##path_used) { \ 
     1523        efree(php->var##path); \ 
     1524        php->var##path = NULL; \ 
     1525        php->var##path_len = 0; \ 
     1526    } 
     1527    if (!const_usage.filepath_used) { 
     1528        php->filepath = NULL; 
     1529        php->filepath_len = 0; 
     1530    } 
     1531    X_FREE_UNUSED(dir) 
     1532#ifdef IS_UNICODE 
     1533    X_FREE_UNUSED(ufile) 
     1534    X_FREE_UNUSED(udir) 
     1535#endif 
     1536#undef X_FREE_UNUSED 
     1537    /* }}} */ 
    12731538#ifdef E_STRICT 
    12741539    php->compilererrors = ((xc_sandbox_t *) XG(sandbox))->compilererrors; 
     
    14671732        php.autoglobals = NULL; 
    14681733#endif 
     1734        memset(&php.op_array_info, 0, sizeof(php.op_array_info)); 
     1735 
    14691736        zend_try { 
    14701737            op_array = xc_compile_php(&php, h, type TSRMLS_CC); 
     
    16381905/* }}} */ 
    16391906 
    1640 #ifdef ZEND_ENGINE_2 
    1641 /* {{{ xc_gc_op_array_t */ 
    1642 typedef struct { 
    1643     zend_uint num_args; 
    1644     zend_arg_info *arg_info; 
    1645 } xc_gc_op_array_t; 
    1646 /* }}} */ 
    1647 void xc_gc_add_op_array(zend_op_array *op_array TSRMLS_DC) /* {{{ */ 
    1648 { 
    1649     xc_gc_op_array_t gc_op_array; 
    1650     gc_op_array.num_args = op_array->num_args; 
    1651     gc_op_array.arg_info = op_array->arg_info; 
    1652 #ifdef ZEND_ENGINE_2 
    1653     zend_llist_add_element(&XG(gc_op_arrays), (void *) &gc_op_array); 
    1654 #endif 
     1907void xc_gc_add_op_array(xc_gc_op_array_t *gc_op_array TSRMLS_DC) /* {{{ */ 
     1908{ 
     1909    zend_llist_add_element(&XG(gc_op_arrays), (void *) gc_op_array); 
    16551910} 
    16561911/* }}} */ 
     
    16591914    xc_gc_op_array_t *op_array = (xc_gc_op_array_t *) pDest; 
    16601915    zend_uint i; 
     1916#ifdef ZEND_ENGINE_2 
    16611917    if (op_array->arg_info) { 
    16621918        for (i = 0; i < op_array->num_args; i++) { 
     
    16681924        efree(op_array->arg_info); 
    16691925    } 
    1670 } 
    1671 /* }}} */ 
    1672 #endif 
     1926#endif 
     1927    if (op_array->opcodes) { 
     1928        efree(op_array->opcodes); 
     1929    } 
     1930} 
     1931/* }}} */ 
    16731932 
    16741933/* module helper function */ 
Note: See TracChangeset for help on using the changeset viewer.