[0001]
[0002]
[0003]
[0004]
[0005]
[0006]
[0007]
[0008]
[0009]
[0010]
[0011]
[0012]
[0013]
[0014]
[0015]
[0016]
[0017]
[0018]
[0019]
[0020]
[0021]
[0022]
[0023]
[0024]
[0025]
[0026]
[0027]
[0028]
[0029]
[0030]
[0031]
[0032]
[0033]
[0034]
[0035]
[0036]
[0037]
[0038]
[0039]
[0040]
[0041]
[0042]
[0043]
[0044]
[0045]
[0046]
[0047]
[0048]
[0049]
[0050]
[0051]
[0052]
[0053]
[0054]
[0055]
[0056]
[0057]
[0058]
[0059]
[0060]
[0061]
[0062]
[0063]
[0064]
[0065]
[0066]
[0067]
[0068]
[0069]
[0070]
[0071]
[0072]
[0073]
[0074]
[0075]
[0076]
[0077]
[0078]
[0079]
[0080]
[0081]
[0082]
[0083]
[0084]
[0085]
[0086]
[0087]
[0088]
[0089]
[0090]
[0091]
[0092]
[0093]
[0094]
[0095]
[0096]
[0097]
[0098]
[0099]
[0100]
[0101]
[0102]
[0103]
[0104]
[0105]
[0106]
[0107]
[0108]
[0109]
[0110]
[0111]
[0112]
[0113]
[0114]
[0115]
[0116]
[0117]
[0118]
[0119]
[0120]
[0121]
[0122]
[0123]
[0124]
[0125]
[0126]
[0127]
[0128]
[0129]
[0130]
[0131]
[0132]
[0133]
[0134]
[0135]
[0136]
[0137]
[0138]
[0139]
[0140]
[0141]
[0142]
[0143]
[0144]
[0145]
[0146]
[0147]
[0148]
[0149]
[0150]
[0151]
[0152]
[0153]
[0154]
[0155]
[0156]
[0157]
[0158]
[0159]
[0160]
[0161]
[0162]
[0163]
[0164]
[0165]
[0166]
[0167]
[0168]
[0169]
[0170]
[0171]
[0172]
[0173]
[0174]
[0175]
[0176]
[0177]
[0178]
[0179]
[0180]
[0181]
[0182]
[0183]
[0184]
[0185]
[0186]
[0187]
[0188]
[0189]
[0190]
[0191]
[0192]
[0193]
[0194]
[0195]
[0196]
[0197]
[0198]
[0199]
[0200]
[0201]
[0202]
[0203]
[0204]
[0205]
[0206]
[0207]
[0208]
[0209]
[0210]
[0211]
[0212]
[0213]
[0214]
[0215]
[0216]
[0217]
[0218]
[0219]
[0220]
[0221]
[0222]
[0223]
[0224]
[0225]
[0226]
[0227]
[0228]
[0229]
[0230]
[0231]
[0232]
[0233]
[0234]
[0235]
[0236]
[0237]
[0238]
[0239]
[0240]
[0241]
[0242]
[0243]
[0244]
[0245]
[0246]
[0247]
[0248]
[0249]
[0250]
[0251]
[0252]
[0253]
[0254]
[0255]
[0256]
[0257]
[0258]
[0259]
[0260]
[0261]
[0262]
[0263]
[0264]
[0265]
[0266]
[0267]
[0268]
[0269]
[0270]
[0271]
[0272]
[0273]
[0274]
[0275]
[0276]
[0277]
[0278]
[0279]
[0280]
[0281]
[0282]
[0283]
[0284]
[0285]
[0286]
[0287]
[0288]
[0289]
[0290]
[0291]
[0292]
[0293]
[0294]
[0295]
[0296]
[0297]
[0298]
[0299]
[0300]
[0301]
[0302]
[0303]
[0304]
[0305]
[0306]
[0307]
[0308]
[0309]
[0310]
[0311]
[0312]
[0313]
[0314]
[0315]
[0316]
[0317]
[0318]
[0319]
[0320]
[0321]
[0322]
[0323]
[0324]
[0325]
[0326]
[0327]
[0328]
[0329]
[0330]
[0331]
[0332]
[0333]
[0334]
[0335]
[0336]
[0337]
[0338]
[0339]
[0340]
[0341]
[0342]
[0343]
[0344]
[0345]
[0346]
[0347]
[0348]
[0349]
[0350]
[0351]
[0352]
[0353]
[0354]
[0355]
[0356]
[0357]
[0358]
[0359]
[0360]
[0361]
[0362]
[0363]
[0364]
[0365]
[0366]
[0367]
[0368]
[0369]
[0370]
[0371]
[0372]
[0373]
[0374]
[0375]
[0376]
[0377]
[0378]
[0379]
[0380]
[0381]
[0382]
[0383]
[0384]
[0385]
[0386]
[0387]
[0388]
[0389]
[0390]
[0391]
[0392]
[0393]
[0394]
[0395]
[0396]
[0397]
[0398]
[0399]
[0400]
[0401]
[0402]
[0403]
[0404]
[0405]
[0406]
[0407]
[0408]
[0409]
[0410]
[0411]
[0412]
[0413]
[0414]
[0415]
[0416]
[0417]
[0418]
[0419]
[0420]
[0421]
[0422]
[0423]
[0424]
[0425]
[0426]
[0427]
[0428]
[0429]
[0430]
[0431]
[0432]
[0433]
[0434]
[0435]
[0436]
[0437]
[0438]
[0439]
[0440]
[0441]
[0442]
[0443]
[0444]
[0445]
[0446]
[0447]
[0448]
[0449]
[0450]
[0451]
[0452]
[0453]
[0454]
[0455]
[0456]
[0457]
[0458]
[0459]
[0460]
[0461]
[0462]
[0463]
[0464]
[0465]
[0466]
[0467]
[0468]
[0469]
[0470]
[0471]
[0472]
[0473]
[0474]
[0475]
[0476]
[0477]
[0478]
[0479]
[0480]
[0481]
[0482]
[0483]
[0484]
[0485]
[0486]
[0487]
[0488]
[0489]
[0490]
[0491]
[0492]
[0493]
[0494]
[0495]
[0496]
[0497]
[0498]
[0499]
[0500]
[0501]
[0502]
[0503]
[0504]
[0505]
[0506]
[0507]
[0508]
[0509]
[0510]
[0511]
[0512]
[0513]
[0514]
[0515]
[0516]
[0517]
[0518]
[0519]
[0520]
[0521]
[0522]
[0523]
[0524]
[0525]
[0526]
[0527]
[0528]
[0529]
[0530]
[0531]
[0532]
[0533]
[0534]
[0535]
[0536]
[0537]
[0538]
[0539]
[0540]
[0541]
[0542]
[0543]
[0544]
[0545]
[0546]
[0547]
[0548]
[0549]
[0550]
[0551]
[0552]
[0553]
[0554]
[0555]
[0556]
[0557]
[0558]
[0559]
[0560]
[0561]
[0562]
[0563]
[0564]
[0565]
[0566]
[0567]
[0568]
[0569]
[0570]
[0571]
[0572]
[0573]
[0574]
[0575]
[0576]
[0577]
[0578]
[0579]
[0580]
[0581]
[0582]
[0583]
[0584]
[0585]
[0586]
[0587]
[0588]
[0589]
[0590]
[0591]
[0592]
[0593]
[0594]
[0595]
[0596]
[0597]
[0598]
[0599]
[0600]
[0601]
[0602]
[0603]
[0604]
[0605]
[0606]
[0607]
[0608]
[0609]
[0610]
[0611]
[0612]
[0613]
[0614]
[0615]
[0616]
[0617]
[0618]
[0619]
[0620]
[0621]
[0622]
[0623]
[0624]
[0625]
[0626]
[0627]
[0628]
[0629]
[0630]
[0631]
[0632]
[0633]
[0634]
[0635]
[0636]
[0637]
[0638]
[0639]
[0640]
[0641]
[0642]
[0643]
[0644]
[0645]
[0646]
[0647]
[0648]
[0649]
[0650]
[0651]
[0652]
[0653]
[0654]
[0655]
[0656]
[0657]
[0658]
[0659]
[0660]
[0661]
[0662]
[0663]
[0664]
[0665]
[0666]
[0667]
[0668]
[0669]
[0670]
[0671]
[0672]
[0673]
[0674]
[0675]
[0676]
[0677]
[0678]
[0679]
[0680]
[0681]
[0682]
[0683]
[0684]
[0685]
[0686]
[0687]
[0688]
[0689]
[0690]
[0691]
[0692]
[0693]
[0694]
[0695]
[0696]
[0697]
[0698]
[0699]
[0700]
[0701]
[0702]
[0703]
[0704]
[0705]
[0706]
[0707]
[0708]
[0709]
[0710]
[0711]
[0712]
[0713]
[0714]
[0715]
[0716]
[0717]
[0718]
[0719]
[0720]
[0721]
[0722]
[0723]
[0724]
[0725]
[0726]
[0727]
[0728]
[0729]
[0730]
[0731]
[0732]
[0733]
[0734]
[0735]
[0736]
[0737]
[0738]
[0739]
[0740]
[0741]
[0742]
[0743]
[0744]
[0745]
[0746]
[0747]
[0748]
[0749]
[0750]
[0751]
[0752]
[0753]
[0754]
[0755]
[0756]
[0757]
[0758]
[0759]
[0760]
[0761]
[0762]
[0763]
[0764]
[0765]
[0766]
[0767]
[0768]
[0769]
[0770]
[0771]
[0772]
[0773]
[0774]
[0775]
[0776]
[0777]
[0778]
[0779]
[0780]
[0781]
[0782]
[0783]
[0784]
[0785]
[0786]
[0787]
[0788]
[0789]
[0790]
[0791]
[0792]
[0793]
[0794]
[0795]
[0796]
[0797]
[0798]
[0799]
[0800]
[0801]
[0802]
[0803]
[0804]
[0805]
[0806]
[0807]
[0808]
[0809]
[0810]
[0811]
[0812]
[0813]
[0814]
[0815]
[0816]
[0817]
[0818]
[0819]
[0820]
[0821]
[0822]
[0823]
[0824]
[0825]
[0826]
[0827]
[0828]
[0829]
[0830]
[0831]
[0832]
[0833]
[0834]
[0835]
[0836]
[0837]
[0838]
[0839]
[0840]
[0841]
[0842]
[0843]
[0844]
[0845]
[0846]
[0847]
[0848]
[0849]
[0850]
[0851]
[0852]
[0853]
[0854]
[0855]
[0856]
[0857]
[0858]
[0859]
[0860]
[0861]
[0862]
[0863]
[0864]
[0865]
[0866]
[0867]
[0868]
[0869]
[0870]
[0871]
[0872]
[0873]
[0874]
[0875]
[0876]
[0877]
[0878]
[0879]
[0880]
[0881]
[0882]
[0883]
[0884]
[0885]
[0886]
[0887]
[0888]
[0889]
[0890]
[0891]
[0892]
[0893]
[0894]
[0895]
[0896]
[0897]
[0898]
[0899]
[0900]
[0901]
[0902]
[0903]
[0904]
[0905]
[0906]
[0907]
[0908]
[0909]
[0910]
[0911]
[0912]
[0913]
[0914]
[0915]
[0916]
[0917]
[0918]
[0919]
[0920]
[0921]
[0922]
[0923]
[0924]
[0925]
[0926]
[0927]
[0928]
[0929]
[0930]
[0931]
[0932]
[0933]
[0934]
[0935]
[0936]
[0937]
[0938]
[0939]
[0940]
[0941]
[0942]
[0943]
[0944]
[0945]
[0946]
[0947]
[0948]
[0949]
[0950]
[0951]
[0952]
[0953]
[0954]
[0955]
[0956]
[0957]
[0958]
[0959]
[0960]
[0961]
[0962]
[0963]
[0964]
[0965]
[0966]
[0967]
[0968]
[0969]
[0970]
[0971]
[0972]
[0973]
[0974]
[0975]
[0976]
[0977]
[0978]
[0979]
[0980]
[0981]
[0982]
[0983]
[0984]
[0985]
[0986]
[0987]
[0988]
[0989]
[0990]
[0991]
[0992]
[0993]
[0994]
[0995]
[0996]
[0997]
[0998]
[0999]
[1000]
[1001]
[1002]
[1003]
[1004]
[1005]
[1006]
[1007]
[1008]
[1009]
[1010]
[1011]
[1012]
[1013]
[1014]
[1015]
[1016]
[1017]
[1018]
[1019]
[1020]
[1021]
[1022]
[1023]
[1024]
[1025]
[1026]
[1027]
[1028]
[1029]
[1030]
[1031]
[1032]
[1033]
[1034]
[1035]
[1036]
[1037]
[1038]
[1039]
[1040]
[1041]
[1042]
[1043]
[1044]
[1045]
[1046]
[1047]
[1048]
[1049]
[1050]
[1051]
[1052]
[1053]
[1054]
[1055]
[1056]
[1057]
[1058]
[1059]
[1060]
[1061]
[1062]
[1063]
[1064]
[1065]
[1066]
[1067]
[1068]
[1069]
[1070]
[1071]
[1072]
[1073]
[1074]
[1075]
[1076]
[1077]
[1078]
[1079]
[1080]
[1081]
[1082]
[1083]
[1084]
[1085]
[1086]
[1087]
[1088]
[1089]
[1090]
[1091]
[1092]
[1093]
[1094]
[1095]
[1096]
[1097]
[1098]
[1099]
[1100]
[1101]
[1102]
[1103]
[1104]
[1105]
[1106]
[1107]
[1108]
[1109]
[1110]
[1111]
[1112]
[1113]
[1114]
[1115]
[1116]
[1117]
[1118]
[1119]
[1120]
[1121]
[1122]
[1123]
[1124]
[1125]
[1126]
[1127]
[1128]
[1129]
[1130]
[1131]
[1132]
[1133]
[1134]
[1135]
[1136]
[1137]
[1138]
[1139]
[1140]
[1141]
[1142]
[1143]
[1144]
[1145]
[1146]
[1147]
[1148]
[1149]
[1150]
[1151]
[1152]
[1153]
[1154]
[1155]
[1156]
[1157]
[1158]
[1159]
[1160]
[1161]
[1162]
[1163]
[1164]
[1165]
[1166]
[1167]
[1168]
[1169]
[1170]
[1171]
[1172]
[1173]
[1174]
[1175]
[1176]
[1177]
[1178]
[1179]
[1180]
[1181]
[1182]
[1183]
[1184]
[1185]
[1186]
[1187]
[1188]
[1189]
[1190]
[1191]
[1192]
[1193]
[1194]
[1195]
[1196]
[1197]
[1198]
[1199]
[1200]
[1201]
[1202]
[1203]
[1204]
[1205]
[1206]
[1207]
[1208]
[1209]
[1210]
[1211]
[1212]
[1213]
[1214]
[1215]
[1216]
[1217]
[1218]
[1219]
[1220]
[1221]
[1222]
[1223]
[1224]
[1225]
[1226]
[1227]
[1228]
[1229]
[1230]
[1231]
[1232]
[1233]
[1234]
[1235]
[1236]
[1237]
[1238]
[1239]
[1240]
[1241]
[1242]
[1243]
[1244]
[1245]
[1246]
[1247]
[1248]
[1249]
[1250]
[1251]
[1252]
[1253]
[1254]
[1255]
[1256]
[1257]
[1258]
[1259]
[1260]
[1261]
[1262]
[1263]
[1264]
[1265]
[1266]
[1267]
[1268]
[1269]
[1270]
[1271]
[1272]
[1273]
[1274]
[1275]
[1276]
[1277]
[1278]
[1279]
[1280]
[1281]
[1282]
[1283]
[1284]
[1285]
[1286]
[1287]
[1288]
[1289]
[1290]
[1291]
[1292]
[1293]
[1294]
[1295]
[1296]
[1297]
[1298]
[1299]
[1300]
[1301]
[1302]
[1303]
[1304]
[1305]
[1306]
[1307]
[1308]
[1309]
[1310]
[1311]
[1312]
[1313]
[1314]
[1315]
[1316]
[1317]
[1318]
[1319]
[1320]
[1321]
[1322]
[1323]
[1324]
[1325]
[1326]
[1327]
[1328]
[1329]
[1330]
[1331]
[1332]
[1333]
[1334]
[1335]
[1336]
[1337]
[1338]
[1339]
[1340]
[1341]
[1342]
[1343]
[1344]
[1345]
[1346]
[1347]
[1348]
[1349]
[1350]
[1351]
[1352]
[1353]
[1354]
[1355]
[1356]
[1357]
[1358]
[1359]
[1360]
[1361]
[1362]
[1363]
[1364]
[1365]
[1366]
[1367]
[1368]
[1369]
[1370]
[1371]
[1372]
[1373]
[1374]
[1375]
[1376]
[1377]
[1378]
[1379]
[1380]
[1381]
[1382]
[1383]
[1384]
[1385]
[1386]
[1387]
[1388]
[1389]
[1390]
[1391]
[1392]
[1393]
[1394]
[1395]
[1396]
[1397]
[1398]
[1399]
[1400]
[1401]
[1402]
[1403]
[1404]
[1405]
[1406]
[1407]
[1408]
[1409]
[1410]
[1411]
[1412]
[1413]
[1414]
[1415]
[1416]
[1417]
[1418]
[1419]
[1420]
[1421]
[1422]
[1423]
[1424]
[1425]
[1426]
[1427]
[1428]
[1429]
[1430]
[1431]
[1432]
[1433]
[1434]
[1435]
[1436]
[1437]
[1438]
[1439]
[1440]
[1441]
[1442]
[1443]
[1444]
[1445]
[1446]
[1447]
[1448]
[1449]
[1450]
[1451]
[1452]
[1453]
[1454]
[1455]
[1456]
[1457]
[1458]
[1459]
[1460]
[1461]
[1462]
[1463]
[1464]
[1465]
[1466]
[1467]
[1468]
[1469]
[1470]
[1471]
[1472]
[1473]
[1474]
[1475]
[1476]
[1477]
[1478]
[1479]
[1480]
[1481]
[1482]
[1483]
[1484]
[1485]
[1486]
[1487]
[1488]
[1489]
[1490]
[1491]
[1492]
[1493]
[1494]
[1495]
[1496]
[1497]
[1498]
[1499]
[1500]
[1501]
[1502]
[1503]
[1504]
[1505]
[1506]
[1507]
[1508]
[1509]
[1510]
[1511]
[1512]
[1513]
[1514]
[1515]
[1516]
[1517]
[1518]
[1519]
[1520]
[1521]
[1522]
[1523]
[1524]
[1525]
[1526]
[1527]
[1528]
[1529]
[1530]
[1531]
[1532]
[1533]
[1534]
[1535]
[1536]
[1537]
[1538]
[1539]
[1540]
[1541]
[1542]
[1543]
[1544]
[1545]
[1546]
[1547]
[1548]
[1549]
[1550]
[1551]
[1552]
[1553]
[1554]
[1555]
[1556]
[1557]
[1558]
[1559]
[1560]
[1561]
[1562]
[1563]
[1564]
[1565]
[1566]
[1567]
[1568]
[1569]
[1570]
[1571]
[1572]
[1573]
[1574]
[1575]
[1576]
[1577]
[1578]
[1579]
[1580]
[1581]
[1582]
[1583]
[1584]
[1585]
[1586]
[1587]
[1588]
[1589]
[1590]
[1591]
[1592]
[1593]
[1594]
[1595]
[1596]
[1597]
[1598]
[1599]
[1600]
[1601]
[1602]
[1603]
[1604]
[1605]
[1606]
[1607]
[1608]
[1609]
[1610]
[1611]
[1612]
[1613]
[1614]
[1615]
[1616]
[1617]
[1618]
[1619]
[1620]
[1621]
[1622]
[1623]
[1624]
[1625]
[1626]
[1627]
[1628]
[1629]
[1630]
[1631]
[1632]
[1633]
[1634]
[1635]
[1636]
[1637]
[1638]
[1639]
[1640]
[1641]
[1642]
[1643]
[1644]
[1645]
[1646]
[1647]
[1648]
[1649]
[1650]
[1651]
[1652]
[1653]
[1654]
[1655]
[1656]
[1657]
[1658]
[1659]
[1660]
[1661]
[1662]
[1663]
[1664]
[1665]
[1666]
[1667]
[1668]
[1669]
[1670]
[1671]
[1672]
[1673]
[1674]
[1675]
[1676]
[1677]
[1678]
[1679]
[1680]
[1681]
[1682]
[1683]
[1684]
[1685]
[1686]
[1687]
[1688]
[1689]
[1690]
[1691]
[1692]
[1693]
[1694]
[1695]
[1696]
[1697]
[1698]
[1699]
[1700]
[1701]
[1702]
[1703]
[1704]
[1705]
[1706]
[1707]
[1708]
[1709]
[1710]
[1711]
[1712]
[1713]
[1714]
[1715]
[1716]
[1717]
[1718]
[1719]
[1720]
[1721]
[1722]
[1723]
[1724]
[1725]
[1726]
[1727]
[1728]
[1729]
[1730]
[1731]
[1732]
[1733]
[1734]
[1735]
[1736]
[1737]
[1738]
[1739]
[1740]
[1741]
[1742]
[1743]
[1744]
[1745]
[1746]
[1747]
[1748]
[1749]
[1750]
[1751]
[1752]
[1753]
[1754]
[1755]
[1756]
[1757]
[1758]
[1759]
[1760]
[1761]
[1762]
[1763]
[1764]
[1765]
[1766]
[1767]
[1768]
[1769]
[1770]
[1771]
[1772]
[1773]
[1774]
[1775]
[1776]
[1777]
[1778]
[1779]
[1780]
[1781]
[1782]
[1783]
[1784]
[1785]
[1786]
[1787]
[1788]
[1789]
[1790]
[1791]
[1792]
[1793]
[1794]
[1795]
[1796]
[1797]
[1798]
[1799]
[1800]
[1801]
[1802]
[1803]
[1804]
[1805]
[1806]
[1807]
[1808]
[1809]
[1810]
[1811]
[1812]
[1813]
[1814]
[1815]
[1816]
[1817]
[1818]
[1819]
[1820]
[1821]
[1822]
[1823]
[1824]
[1825]
[1826]
[1827]
[1828]
[1829]
[1830]
[1831]
[1832]
[1833]
[1834]
[1835]
[1836]
[1837]
[1838]
[1839]
[1840]
[1841]
[1842]
[1843]
[1844]
[1845]
[1846]
[1847]
[1848]
[1849]
[1850]
[1851]
[1852]
[1853]
[1854]
[1855]
[1856]
[1857]
[1858]
[1859]
[1860]
[1861]
[1862]
[1863]
[1864]
[1865]
[1866]
[1867]
[1868]
[1869]
[1870]
[1871]
[1872]
[1873]
[1874]
[1875]
[1876]
[1877]
[1878]
[1879]
[1880]
[1881]
[1882]
[1883]
[1884]
[1885]
[1886]
[1887]
[1888]
[1889]
[1890]
[1891]
[1892]
[1893]
[1894]
[1895]
[1896]
[1897]
[1898]
[1899]
[1900]
[1901]
[1902]
[1903]
[1904]
[1905]
[1906]
[1907]
[1908]
[1909]
[1910]
[1911]
[1912]
[1913]
[1914]
[1915]
[1916]
[1917]
[1918]
[1919]
[1920]
[1921]
[1922]
[1923]
[1924]
[1925]
[1926]
[1927]
[1928]
[1929]
[1930]
[1931]
[1932]
[1933]
[1934]
[1935]
[1936]
[1937]
[1938]
[1939]
[1940]
[1941]
[1942]
[1943]
[1944]
[1945]
[1946]
[1947]
[1948]
[1949]
[1950]
[1951]
[1952]
[1953]
[1954]
[1955]
[1956]
[1957]
[1958]
[1959]
[1960]
[1961]
[1962]
[1963]
[1964]
[1965]
[1966]
[1967]
[1968]
[1969]
[1970]
[1971]
[1972]
[1973]
[1974]
[1975]
[1976]
[1977]
[1978]
[1979]
[1980]
[1981]
[1982]
[1983]
[1984]
[1985]
[1986]
[1987]
[1988]
[1989]
[1990]
[1991]
[1992]
[1993]
[1994]
[1995]
[1996]
[1997]
[1998]
[1999]
[2000]
[2001]
[2002]
[2003]
[2004]
[2005]
[2006]
[2007]
[2008]
[2009]
[2010]
[2011]
[2012]
[2013]
[2014]
[2015]
[2016]
[2017]
[2018]
[2019]
[2020]
[2021]
[2022]
[2023]
[2024]
[2025]
[2026]
[2027]
[2028]
[2029]
[2030]
[2031]
[2032]
[2033]
[2034]
[2035]
[2036]
[2037]
[2038]
[2039]
[2040]
[2041]
[2042]
[2043]
[2044]
[2045]
[2046]
[2047]
[2048]
[2049]
[2050]
[2051]
[2052]
[2053]
[2054]
[2055]
[2056]
[2057]
[2058]
[2059]
[2060]
[2061]
[2062]
[2063]
[2064]
[2065]
[2066]
[2067]
[2068]
[2069]
[2070]
[2071]
[2072]
[2073]
[2074]
[2075]
[2076]
[2077]
[2078]
[2079]
[2080]
[2081]
[2082]
[2083]
[2084]
[2085]
[2086]
[2087]
[2088]
[2089]
[2090]
[2091]
[2092]
[2093]
[2094]
[2095]
[2096]
[2097]
[2098]
[2099]
[2100]
[2101]
[2102]
[2103]
[2104]
[2105]
[2106]
[2107]
[2108]
[2109]
[2110]
[2111]
[2112]
[2113]
[2114]
[2115]
[2116]
[2117]
[2118]
[2119]
[2120]
[2121]
[2122]
[2123]
[2124]
[2125]
[2126]
[2127]
[2128]
[2129]
[2130]
[2131]
[2132]
[2133]
[2134]
[2135]
[2136]
[2137]
[2138]
[2139]
[2140]
[2141]
[2142]
[2143]
[2144]
[2145]
[2146]
[2147]
[2148]
[2149]
[2150]
[2151]
[2152]
[2153]
[2154]
[2155]
[2156]
[2157]
[2158]
[2159]
[2160]
[2161]
[2162]
[2163]
[2164]
[2165]
[2166]
[2167]
[2168]
[2169]
[2170]
[2171]
[2172]
[2173]
[2174]
[2175]
[2176]
[2177]
[2178]
[2179]
[2180]
[2181]
[2182]
[2183]
[2184]
[2185]
[2186]
[2187]
[2188]
[2189]
[2190]
[2191]
[2192]
[2193]
[2194]
[2195]
[2196]
[2197]
[2198]
[2199]
[2200]
[2201]
[2202]
[2203]
[2204]
[2205]
[2206]
[2207]
[2208]
[2209]
[2210]
[2211]
[2212]
[2213]
[2214]
[2215]
[2216]
[2217]
[2218]
[2219]
[2220]
[2221]
[2222]
[2223]
[2224]
[2225]
[2226]
[2227]
[2228]
[2229]
[2230]
[2231]
[2232]
[2233]
[2234]
[2235]
[2236]
[2237]
[2238]
[2239]
[2240]
[2241]
[2242]
[2243]
[2244]
[2245]
[2246]
[2247]
[2248]
[2249]
[2250]
[2251]
[2252]
[2253]
[2254]
[2255]
[2256]
[2257]
[2258]
[2259]
[2260]
[2261]
[2262]
[2263]
[2264]
[2265]
[2266]
[2267]
[2268]
[2269]
[2270]
[2271]
[2272]
[2273]
[2274]
[2275]
[2276]
[2277]
[2278]
[2279]
[2280]
[2281]
[2282]
[2283]
[2284]
[2285]
[2286]
[2287]
[2288]
[2289]
[2290]
[2291]
[2292]
[2293]
[2294]
[2295]
[2296]
[2297]
[2298]
[2299]
[2300]
[2301]
[2302]
[2303]
[2304]
[2305]
[2306]
[2307]
[2308]
[2309]
[2310]
[2311]
[2312]
[2313]
[2314]
[2315]
[2316]
[2317]
[2318]
[2319]
[2320]
[2321]
[2322]
[2323]
[2324]
[2325]
[2326]
[2327]
[2328]
[2329]
[2330]
[2331]
[2332]
[2333]
[2334]
[2335]
[2336]
[2337]
[2338]
[2339]
[2340]
[2341]
[2342]
[2343]
[2344]
[2345]
[2346]
[2347]
[2348]
[2349]
[2350]
[2351]
[2352]
[2353]
[2354]
[2355]
[2356]
[2357]
[2358]
[2359]
[2360]
[2361]
[2362]
[2363]
[2364]
[2365]
[2366]
[2367]
[2368]
[2369]
[2370]
[2371]
[2372]
[2373]
[2374]
[2375]
[2376]
[2377]
[2378]
[2379]
[2380]
[2381]
[2382]
[2383]
[2384]
[2385]
[2386]
[2387]
[2388]
[2389]
[2390]
[2391]
[2392]
[2393]
[2394]
[2395]
[2396]
[2397]
[2398]
[2399]
[2400]
[2401]
[2402]
[2403]
[2404]
[2405]
[2406]
[2407]
[2408]
[2409]
[2410]
[2411]
[2412]
[2413]
[2414]
[2415]
[2416]
[2417]
[2418]
[2419]
[2420]
[2421]
[2422]
[2423]
[2424]
[2425]
[2426]
[2427]
[2428]
[2429]
[2430]
[2431]
[2432]
[2433]
[2434]
[2435]
[2436]
[2437]
[2438]
[2439]
[2440]
[2441]
[2442]
[2443]
[2444]
[2445]
[2446]
[2447]
[2448]
[2449]
[2450]
[2451]
[2452]
[2453]
[2454]
[2455]
[2456]
[2457]
[2458]
[2459]
[2460]
[2461]
[2462]
[2463]
[2464]
[2465]
[2466]
[2467]
[2468]
[2469]
[2470]
[2471]
[2472]
[2473]
[2474]
[2475]
[2476]
[2477]
[2478]
[2479]
[2480]
[2481]
[2482]
[2483]
[2484]
[2485]
[2486]
[2487]
[2488]
[2489]
[2490]
[2491]
[2492]
[2493]
[2494]
[2495]
[2496]
[2497]
[2498]
[2499]
[2500]
[2501]
[2502]
[2503]
[2504]
[2505]
[2506]
[2507]
[2508]
[2509]
[2510]
[2511]
[2512]
[2513]
[2514]
[2515]
[2516]
[2517]
[2518]
[2519]
[2520]
[2521]
[2522]
[2523]
[2524]
[2525]
[2526]
[2527]
[2528]
[2529]
[2530]
[2531]
[2532]
[2533]
[2534]
[2535]
[2536]
[2537]
[2538]
[2539]
[2540]
[2541]
[2542]
[2543]
[2544]
[2545]
[2546]
[2547]
[2548]
[2549]
[2550]
[2551]
[2552]
[2553]
[2554]
[2555]
[2556]
[2557]
[2558]
[2559]
[2560]
[2561]
[2562]
[2563]
[2564]
[2565]
[2566]
[2567]
[2568]
[2569]
[2570]
[2571]
[2572]
[2573]
[2574]
[2575]
[2576]
[2577]
[2578]
[2579]
[2580]
[2581]
[2582]
[2583]
[2584]
[2585]
[2586]
[2587]
[2588]
[2589]
[2590]
[2591]
[2592]
[2593]
[2594]
[2595]
[2596]
[2597]
[2598]
[2599]
[2600]
[2601]
[2602]
[2603]
[2604]
[2605]
[2606]
[2607]
[2608]
[2609]
[2610]
[2611]
[2612]
[2613]
[2614]
[2615]
[2616]
[2617]
[2618]
[2619]
[2620]
[2621]
[2622]
[2623]
[2624]
[2625]
[2626]
[2627]
[2628]
[2629]
[2630]
[2631]
[2632]
[2633]
[2634]
[2635]
[2636]
[2637]
[2638]
[2639]
[2640]
[2641]
[2642]
[2643]
[2644]
[2645]
[2646]
[2647]
[2648]
[2649]
[2650]
[2651]
[2652]
[2653]
[2654]
[2655]
[2656]
[2657]
[2658]
[2659]
[2660]
[2661]
[2662]
[2663]
[2664]
[2665]
[2666]
[2667]
[2668]
[2669]
[2670]
[2671]
[2672]
[2673]
[2674]
[2675]
[2676]
[2677]
[2678]
[2679]
[2680]
[2681]
[2682]
[2683]
[2684]
[2685]
[2686]
[2687]
[2688]
[2689]
[2690]
[2691]
[2692]
[2693]
[2694]
[2695]
[2696]
[2697]
[2698]
[2699]
[2700]
[2701]
[2702]
[2703]
[2704]
[2705]
[2706]
[2707]
[2708]
[2709]
[2710]
[2711]
[2712]
[2713]
[2714]
[2715]
[2716]
[2717]
[2718]
[2719]
[2720]
[2721]
[2722]
[2723]
[2724]
[2725]
[2726]
[2727]
[2728]
[2729]
[2730]
[2731]
/*****************************************************************************
/*
VM.c
Virtual memory support functions for HTTPd using the LIB$*_VM_* routines.
The reason for not using generic memory routines such as calloc() and malloc()
for frequently requested and then disposed of dynamic memory is of course
efficiency. The theory goes like this ... tailoring VMS memory zones against
the expected request profile for it's use will result in faster and more
efficient memory management. An added, and not inconsequential bonus, is the
additional integrity checking the library routines can provide.
A general zone is created for non-specific allocations.
Zones for fixed sized memory blocks are created for the HTTP/2 and request
structures.
An individual zone is created for each HTTP/2 connection's and request's heap.
The overhead of zone creation will be offset by the lower overhead required for
managing a smaller and short-lived collection of chunks, and the documentation
specifically states that reseting or deleting a memory zone is a more efficient
method of disposing of virtual memory than individually freeing each chunk.
The request zone has the initial allocation "tuned". After an initial sample
of requests the allocation becomes the running "average" of those requests
(rounded into mutliples of the hard-wired chunk size). This averaging persists
for a period (number of requests) before being reset to the initial sample
state again.
Logical names may be used to tailor the number of pages allocated for the
initial and extend values of the heap zones. The logical name value should be
"<integer-initial>[,<integer-extend>]" (extend value is optional and defaults
to the supplied initial value). Defining an <initial-value> to be -1 disables
LIB$*VM* zone management of the memory and standard DECC functions are used
instead. Statistics are still collected and reported. Some memory management
(e.g. request) must always be managed as a zone. Values are read during server
startup.
Examples:
$ DEFINE /EXECUTIVE /TABLE=WASD_TABLE WASD_VM_CACHE "4096"
$ DEFINE /EXECUTIVE /TABLE=WASD_TABLE WASD_VM_DECC "2048,4096"
$ DEFINE /EXECUTIVE /TABLE=WASD_TABLE WASD_VM_EXPAT "128,128"
$ DEFINE /EXECUTIVE /TABLE=WASD_TABLE WASD_VM_HTTP2 "80,128"
$ DEFINE /EXECUTIVE /TABLE=WASD_TABLE WASD_VM_OPENSSL "-1"
$ DEFINE /EXECUTIVE /TABLE=WASD_TABLE WASD_VM_PERMCACHE "512"
$ DEFINE /EXECUTIVE /TABLE=WASD_TABLE WASD_VM_REQUEST "96,128"
Request with "tune" parameters (sample of 64, and period 100 times greater):
$ DEFINE /EXECUTIVE /TABLE=WASD_TABLE WASD_VM_REQUEST "256,512,64,100"
NOTE: MEMORY MANAGEMENT IS CONSIDERED CRUCIAL TO HTTPD FUNCTIONING
-------------------------------------------------------------------
IF A ZONE ALLOCATION OR FREEING GENERATES AN ERROR (E.G. INSUFFICIENT VIRTUAL,
BAD BLOCK, ETC.) THEN THIS IS CONSIDERED SERIOUS (ESPECIALLY THE LATTER,
INDICATING STRUCTURE CORRUPTION) AND THE SERVER EXITS REPORTING STATUS
INFORMATION.
Hence calls to memory allocation and freeing do not need to check for success
as only successful operations will return to them!
MEMORY CHUNK PROLOGUE
---------------------
All memory allocations contain a small prologue structure immediately in front
of the location returned to the caller. This provides some memory management
data (chunk size and guard magic) and 9 bytes of space immediately adjacent to
the first returned byte. This space is intended to contain an HTTP/2 frame
header immediately preceding data to be written to the network. It is always
present in allocated memory whether used for HTTP/2 framing or not and its
presence detected through some specific magic stored immediately preceding (and
in this manner "close") to the returned pointer. See HTTP2.c and HTTP2NET.C
for further background, example usage, etc.
OPENSSL MEMORY STATISTICS
-------------------------
The OpenSSL memory management calls malloc(), realloc() and free() can be
intercepted by this module and used to provide statistics on their use. The
calls are actually still processed by the DECC run-time equivalent calls.
Compatible with "intercepting DECC calls" but not "OpenSSL memory management".
OPENSSL MEMORY MANAGEMENT
-------------------------
The OpenSSL memory management calls malloc(), realloc() and free() can be
performed by this module using calls associated with dedicated zone "WASD
OpenSSL". This can be used for investigative purpose or in production.
The OpenSSL CRYPTO_set_mem_function() API is used to enable this.
OpenSSL memory management and the DECC emulation are compatible.
Compatible with "intercepting DECC calls" but not "OpenSSL memory statistics".
INTERCEPTING DECC CALLS
-----------------------
The void* VmDecc..() functions are designed to provide a DECC emulation for
development and troubleshooting purposes. Defining VM_DECC macro true will
enable an overloading of the DECC$CALLOC, DECC$MALLOC, DECC$REALLOC and
DECC$FREE functions.
These messages (or CPU equivalent) at link time indicate a successful
overloading and may safely be ignored. Bit messy but hey.
%LINK-W-MULDEF, symbol DECC$REALLOC multiply defined
in module DECC$SHR_EV56 file SYS$COMMON:[SYSLIB]DECC$SHR_EV56.EXE;1
%LINK-W-MULDEF, symbol DECC$MALLOC multiply defined
in module DECC$SHR_EV56 file SYS$COMMON:[SYSLIB]DECC$SHR_EV56.EXE;1
%LINK-W-MULDEF, symbol DECC$CALLOC multiply defined
in module DECC$SHR_EV56 file SYS$COMMON:[SYSLIB]DECC$SHR_EV56.EXE;1
%LINK-W-MULDEF, symbol DECC$FREE multiply defined
in module DECC$SHR_EV56 file SYS$COMMON:[SYSLIB]DECC$SHR_EV56.EXE;1
By default the actual memory management is performed by LIB$*VM*() routines
with a created LIB$ memory zone. If the macro VM_DECC_LIB_VM macro is true
then the memory management is performed by calls to LIB$VM..() calls, a
slightly incestuous code path implemented to gather DECC statistics.
DECC also seems to free() one or two, perhaps more, right at the beginning of
server initialisation, perhaps from DECC initialisation itself. This is
detected by the absence of approprite magic on the memory and would normally be
considered a fatal error. So this code ignores magic-less memory chunks for a
few seconds after server startup.
VAX SUPPORT
-----------
Is limited to the basic functionality of this module and DOES NOT support
using zones for individual non-WASD memory management or statistic gathering
and reporting.
VERSION HISTORY
---------------
20-JUL-2021 MGD confine VmReport() items to WASD zones,
unless logical name WASD_VM_REPORT_ALL is defined
19-NOV-2020 MGD VmGetRequest(), VmFreeHeap() provide "tuned" initial pages
(yep, tuning again...)
11-AUG-2020 MGD VmCheckPgFlLimit() and WASD_VM_PGFL_LIMIT logical name
23-JAN-2020 MGD HTTP/2 heap initial and extend pages 128 to 256
26-JUL-2018 MGD here we go again - rework to pull more statistics
14-JUL-2018 MGD Bonne Fête Nationale!
eliminate dynamic tuning of heap initial allocation
assumes overhead of tuning out-weighs that of area mgmnt
(and after a query and some discussion on comp.os.vms)
add VmOpenSsl..() routines specifically for OpenSSL
add VmDecc..() routines for development and troubleshooting
VmReport() add lib$show_vm_zone_64 (perhaps looking ahead)
01-JUL-2018 MGD VmReport() include WATCH link in heap zone data
04-AUG-2015 MGD support HTTP/2 specific memory management
add magic allowing various allocations to be differentiated
HTTP2_STRUCT and REQUEST_STRUCT sizes via external storage
14-MAR-2011 MGD sizeof(VM_STRUCT) now 8 (natural alignment) instead of 4
04-JUL-2006 MGD use PercentOf32() for more accurate percentages
16-APR-2005 MGD modify statistics to a maximum of 1024 pages and granularity
of 8 (GZIP significantly increased memory requirements)
26-MAR-2005 MGD VmRequestTune() set 'VmRequestSizePages' dynamically
22-MAY-2004 MGD bugfix; VmGetRequest() error exit if zone create fails
27-JAN-2004 MGD VmCacheInit() and VmPermCacheInit() extend size reduced
09-DEC-2003 MGD VmGeneralInit() upped from 1024/1024 to 4096/4096
18-JUN-2003 MGD refine VmRequestTune()
14-JUN-2003 MGD request heap statistics and VmRequestTune()
24-MAY-2003 MGD VmPermCache..()
29-SEP-2001 MGD instance support
04-AUG-2001 MGD support module WATCHing
26-FEB-2001 MGD observation indicates VmGeneralInit() extend up to 1024
04-MAR-2000 MGD use FaolToNet(), et.al.
05-FEB-2000 MGD add module name and line number to VmFree/Realloc...()
16-JUL-1998 MGD observation indicates VmGeneralInit() initial up to 1024
07-DEC-1997 MGD using LIB$*_VM_* routines for virtual memory manipulation
(and unbundled from support.c for v5.0)
*/
/*****************************************************************************/
#ifdef WASD_VMS_V7
#undef _VMS__V6__SOURCE
#define _VMS__V6__SOURCE
#undef __VMS_VER
#define __VMS_VER 70000000
#undef __CRTL_VER
#define __CRTL_VER 70000000
#endif
/* standard C header files */
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
/* VMS related header files */
#include <descrip.h>
#include <jpidef.h>
#include <libdef.h>
#include <libvmdef.h>
#include <ssdef.h>
#include <stsdef.h>
/* application related header files */
#include "wasd.h"
#define WASD_MODULE "VM"
/* allocation quantum for the zone */
#define VM_BLOCK_BYTES 64
/*
Where appropriate allocate an extra few bytes for carriage-control
in buffers, null string terminators, programming errors ;^) etc.
*/
#define VM_ELBOW_ROOM 8
#define VM_GUARD_SIZE sizeof(ulong)
/* all overhead when allocating even a single byte of heap */
#define VM_ALLOC_OVERHEAD (sizeof(VM_STRUCT) + VM_ELBOW_ROOM + VM_GUARD_SIZE)
/* unconditionally control VM module WATCHing - only for troubleshooting! */
#define WATCHON_WATCHOFF 0
/*****************/
/* GENERAL ZONES */
/*****************/
#define VM_REQUEST_INITIAL_PAGES 256
#define VM_REQUEST_EXTEND_PAGES 256
#define VM_REQUEST_MAX_PAGES 1024
#define VM_REQUEST_MIN_PAGES 32
/* tune after sampling this many requests */
#define VM_REQUEST_TUNE_SAMPLE 128
/* continue to tune for this multiple of the sample */
#define VM_REQUEST_TUNE_PERIOD 32
#define VM_HTTP2_INITIAL_PAGES 256
#define VM_HTTP2_EXTEND_PAGES 256
#define VM_HTTP2_MAX_PAGES 2048
#define VM_HTTP2_MIN_PAGES 128
#define VM_GENERAL_INITIAL_PAGES 4096
#define VM_GENERAL_EXTEND_PAGES 2048
#define VM_GENERAL_MAX_PAGES 16384
#define VM_GENERAL_MIN_PAGES 512
#define VM_CACHE_INITIAL_PAGES 1024
#define VM_CACHE_EXTEND_PAGES 1024
#define VM_CACHE_MAX_PAGES 8192
#define VM_CACHE_MIN_PAGES 256
#define VM_PERMCACHE_INITIAL_PAGES 256
#define VM_PERMCACHE_EXTEND_PAGES 256
#define VM_PERMCACHE_MAX_PAGES 8192
#define VM_PERMCACHE_MIN_PAGES 256
/*******/
#if VM_DECC
/*******/
#if VM_OPENSSL
/* if OpenSSL being VM managed then DECC needs a lot less */
# define VM_DECC_INITIAL_PAGES 256
# define VM_DECC_EXTEND_PAGES 256
# define VM_DECC_MAX_PAGES 4096
# define VM_DECC_MIN_PAGES 128
#else
/* if OpenSSL *not* being managed then DECC needs to take up the slack */
# define VM_DECC_INITIAL_PAGES 16384
# define VM_DECC_EXTEND_PAGES 16384
# define VM_DECC_MAX_PAGES 131072
# define VM_DECC_MIN_PAGES 4096
#endif /* VM_OPENSSL */
# ifndef VM_DECC_LIB_VM
# define VM_DECC_LIB_VM 0
# endif
/* overload the local routines onto the DECC routines */
# define VmDeccMalloc DECC$MALLOC
# define VmDeccCalloc DECC$CALLOC
# define VmDeccRealloc DECC$REALLOC
# define VmDeccFree DECC$FREE
#endif /* VM_DECC */
/********/
#if VM_EXPAT
/********/
#define VM_EXPAT_INITIAL_PAGES 256
#define VM_EXPAT_EXTEND_PAGES 256
#define VM_EXPAT_MAX_PAGES 2048
#define VM_EXPAT_MIN_PAGES 128
#endif /* VM_EXPAT */
/**********/
#if VM_OPENSSL
/**********/
#define VM_OPENSSL_INITIAL_PAGES 16384
#define VM_OPENSSL_EXTEND_PAGES 16384
#define VM_OPENSSL_MAX_PAGES 131072
#define VM_OPENSSL_MIN_PAGES 4096
#endif /* VM_OPENSSL */
/******************/
/* global storage */
/******************/
static BOOL VmReportPlus,
VmReportThisOne;
static int VmDeccTickSecond;
static VM_ZONE VmCacheZone;
static VM_ZONE VmGeneralZone;
static VM_ZONE VmHttp2Zone;
static VM_ZONE VmPermCacheZone;
static VM_ZONE VmRequestZone;
static VM_ZONE VmExpatZone;
static VM_ZONE VmOpenSslZone;
#if VM_DECC
static VM_ZONE VmDeccZone;
#endif /* VM_DECC */
/********************/
/* external storage */
/********************/
extern BOOL HttpdServerStartup;
extern int CacheEntryKBytesMax,
CacheTotalKBytesMax,
EfnWait,
HttpdTickSecond,
Http2StructSize,
NetConcurrentMax,
RequestStructSize;
extern char ErrorSanityCheck[],
HttpProtocol[],
SoftwareID[];
extern CONFIG_STRUCT Config;
extern HTTPD_GBLSEC *HttpdGblSecPtr;
extern HTTPD_PROCESS HttpdProcess;
extern WATCH_STRUCT Watch;
/*****************************************************************************/
/*
Initialize virtual memory management.
*/
void VmInit ()
{
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
{
Watch.Module |= WATCH_MOD_VM;
Watch.StdoutOnly = true;
WatchThis (WATCHALL, WATCH_MOD_VM, "VmInit()");
}
VmGeneralInit ();
}
/*****************************************************************************/
/*
Allocate memory for an up-call function.
Malloc is indicated by a chunk number of -1.
*/
void* VmGenericCalloc
(
VM_ZONE *ZonePtr,
int NumChunks,
int ChunkSize,
char *ModuleName,
int LineNumber
)
{
int status;
ulong BaseAddress;
uchar *aptr;
VM_STRUCT *vmptr;
/*********/
/* begin */
/*********/
if (!ZonePtr->ZoneId) ErrorExitVmsStatus (SS$_BUGCHECK, NULL, FI_LI);
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM,
"VmGenericCalloc() 0x!8XL !AZ !SL !SL",
ZonePtr->ZoneId, ZonePtr->ReportTitle,
NumChunks, ChunkSize);
if (!ChunkSize) return (NULL);
if (NumChunks > 1) ChunkSize *= NumChunks;
ChunkSize += VM_ALLOC_OVERHEAD;
if (ZonePtr->ZoneId == (ulong)-1)
{
vmptr = (VM_STRUCT*)lib$vm_calloc (1, ChunkSize);
if (!vmptr) ErrorExitVmsStatus (SS$_BUGCHECK, "lib$vm_calloc()", FI_LI);
}
else
{
status = lib$get_vm (&ChunkSize, &BaseAddress, &ZonePtr->ZoneId);
if (VMSnok (status)) ErrorExitVmsStatus (status, "lib$get_vm()", FI_LI);
vmptr = (VM_STRUCT*)BaseAddress;
}
ChunkSize -= VM_ALLOC_OVERHEAD;
vmptr->size = ChunkSize;
vmptr->magic = ZonePtr->MagicValue;
/* guard is placed at the end of the memory chunk to detect overflow */
aptr = (uchar*)vmptr + (sizeof(VM_STRUCT) + VM_ELBOW_ROOM) + ChunkSize;
*(ULONGPTR)aptr = VM_GUARD;
if (NumChunks < 0)
ZonePtr->MallocCount++;
else
ZonePtr->CallocCount++;
ZonePtr->AllocBytes += ChunkSize;
ZonePtr->InUseBytes = ZonePtr->AllocBytes - ZonePtr->DeallocBytes;
if (ZonePtr->InUseBytes > ZonePtr->InUseMaxBytes)
ZonePtr->InUseMaxBytes = ZonePtr->InUseBytes;
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM, "!UL !UL !8XL !8XL",
vmptr, vmptr->size, vmptr->magic, *(ULONGPTR)aptr);
return ((uchar*)vmptr + sizeof(VM_STRUCT));
}
/*****************************************************************************/
/*
Expand generic chunk. See VmGenericCalloc().
*/
void* VmGenericRealloc
(
VM_ZONE *ZonePtr,
uchar *ChunkPtr,
int ChunkSize,
char *ModuleName,
int LineNumber
)
{
int status;
ulong BaseAddress,
TheBaseAddress,
TheChunkSize;
uchar *aptr;
VM_STRUCT *vmptr;
/*********/
/* begin */
/*********/
if (!ZonePtr->ZoneId) ErrorExitVmsStatus (SS$_BUGCHECK, NULL, FI_LI);
if (ChunkPtr)
TheChunkSize = ((VM_STRUCT*)(ChunkPtr-sizeof(VM_STRUCT)))->size;
else
TheChunkSize = -1;
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM,
"VmGenericRealloc() 0x!8XL !AZ !SL !SL !AZ:!UL",
ZonePtr->ZoneId, ZonePtr->ReportTitle,
TheChunkSize, ChunkSize, ModuleName, LineNumber);
if (!ChunkPtr && ChunkSize)
return (VmGenericCalloc (ZonePtr, -1, ChunkSize, ModuleName, LineNumber));
if (ChunkPtr && !ChunkSize)
{
VmGenericFree (ZonePtr, ChunkPtr, ModuleName, LineNumber);
return (NULL);
}
if (!ChunkSize) return (NULL);
vmptr = (VM_STRUCT*)(TheBaseAddress = ChunkPtr - sizeof(VM_STRUCT));
aptr = (uchar*)vmptr + (sizeof(VM_STRUCT) + VM_ELBOW_ROOM) + TheChunkSize;
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM, "!UL !UL !8XL !8XL",
vmptr, vmptr->size, vmptr->magic, *(ULONGPTR)aptr);
if (vmptr->magic != ZonePtr->MagicValue)
ErrorExitVmsStatus (SS$_BUGCHECK, "magic", ModuleName, LineNumber);
if (*(ULONGPTR)aptr != VM_GUARD)
ErrorExitVmsStatus (SS$_BUGCHECK, "guard", ModuleName, LineNumber);
/* if this chunk satisfies the reallocation then just return it */
TheChunkSize = ((VM_STRUCT*)TheBaseAddress)->size;
if (TheChunkSize >= ChunkSize) return (ChunkPtr);
/* allocate a new, larger chunk */
ChunkSize += VM_ALLOC_OVERHEAD;
if (ZonePtr->ZoneId == (ulong)-1)
{
vmptr = (VM_STRUCT*)lib$vm_calloc (1, ChunkSize);
if (!vmptr) return (NULL);
}
else
{
status = lib$get_vm (&ChunkSize, &BaseAddress, &ZonePtr->ZoneId);
if (VMSnok (status)) ErrorExitVmsStatus (status, "lib$get_vm()", FI_LI);
vmptr = (VM_STRUCT*)BaseAddress;
}
ChunkSize -= VM_ALLOC_OVERHEAD;
/* copy the existing chunk into the new chunk */
if (TheChunkSize > 0)
memcpy (vmptr,
(uchar*)TheBaseAddress,
TheChunkSize + (sizeof(VM_STRUCT) + VM_ELBOW_ROOM));
aptr = (uchar*)vmptr + (sizeof(VM_STRUCT) + VM_ELBOW_ROOM) + ChunkSize;
*(ULONGPTR)aptr = VM_GUARD;
/* update the chunk size */
vmptr->size = ChunkSize;
/* this is the GROWTH in memory due to reallocation */
ZonePtr->ReallocCount++;
ZonePtr->AllocBytes += ChunkSize - TheChunkSize;
ZonePtr->InUseBytes = ZonePtr->AllocBytes - ZonePtr->DeallocBytes;
if (ZonePtr->InUseBytes > ZonePtr->InUseMaxBytes)
ZonePtr->InUseMaxBytes = ZonePtr->InUseBytes;
/* free the previous chunk */
if (ZonePtr->ZoneId == (ulong)-1)
lib$vm_free ((void*)TheBaseAddress);
else
{
status = lib$free_vm (0, &TheBaseAddress, &ZonePtr->ZoneId);
if (VMSnok (status))
ErrorExitVmsStatus (status, "lib$free_vm()", ModuleName, LineNumber);
}
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM, "!UL !UL !8XL !8XL",
vmptr, vmptr->size, vmptr->magic, *(ULONGPTR)aptr);
return ((uchar*)vmptr + sizeof(VM_STRUCT));
}
/*****************************************************************************/
/*
Release memory allocated for generic use.
*/
void VmGenericFree
(
VM_ZONE *ZonePtr,
uchar *ChunkPtr,
char *ModuleName,
int LineNumber
)
{
int status,
ChunkSize;
ulong BaseAddress;
uchar *aptr;
VM_STRUCT *vmptr;
/*********/
/* begin */
/*********/
if (!ZonePtr->ZoneId) ErrorExitVmsStatus (SS$_BUGCHECK, NULL, FI_LI);
if (ChunkPtr)
ChunkSize = ((VM_STRUCT*)(ChunkPtr-sizeof(VM_STRUCT)))->size;
else
ChunkSize = 0;
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM,
"VmGenericFree() 0x!8XL !AZ !SL !AZ:!UL",
ZonePtr->ZoneId, ZonePtr->ReportTitle, ChunkSize,
ModuleName, LineNumber);
if (!ChunkPtr) return;
vmptr = (VM_STRUCT*)(BaseAddress = ChunkPtr - sizeof(VM_STRUCT));
aptr = (uchar*)vmptr + (sizeof(VM_STRUCT) + VM_ELBOW_ROOM) + ChunkSize;
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM, "!UL !UL !8XL !8XL",
vmptr, vmptr->size, vmptr->magic, *(ULONGPTR)aptr);
/* see module prologue for explanation */
if (vmptr->magic != ZonePtr->MagicValue)
ErrorExitVmsStatus (SS$_BUGCHECK, "magic", ModuleName, LineNumber);
if (*(ULONGPTR)aptr != VM_GUARD)
ErrorExitVmsStatus (SS$_BUGCHECK, "guard", ModuleName, LineNumber);
ZonePtr->FreeCount++;
ZonePtr->DeallocBytes += ChunkSize;
ZonePtr->InUseBytes = ZonePtr->AllocBytes - ZonePtr->DeallocBytes;
if (ZonePtr->InUseBytes > ZonePtr->InUseMaxBytes)
ZonePtr->InUseMaxBytes = ZonePtr->InUseBytes;
if (ZonePtr->ZoneId == (ulong)-1)
lib$vm_free ((void*)BaseAddress);
else
{
status = lib$free_vm (0, &BaseAddress, &ZonePtr->ZoneId);
if (VMSnok (status))
ErrorExitVmsStatus (status, "lib$free_vm()", ModuleName, LineNumber);
}
}
/*****************************************************************************/
/*
Initialize the virtual memory zone general memory will be allocated from.
Also take parameters from logical names described above if present.
*/
void VmGeneralInit ()
{
static $DESCRIPTOR (ZoneNameDsc, "WASD General");
static ulong Algorithm = LIB$K_VM_QUICK_FIT,
AlgorithmArg = 64,
Flags = LIB$M_VM_BOUNDARY_TAGS |
LIB$M_VM_GET_FILL0 |
LIB$M_VM_TAIL_LARGE,
ExtendPages = 4096,
InitialPages = 4096,
BlockBytes = VM_BLOCK_BYTES;
int status;
char *cptr;
VM_ZONE *vzptr = &VmGeneralZone;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM, "VmGeneralInit()");
vzptr->MagicValue = VM_MAGIC_GENERAL;
vzptr->MaxPages = VM_GENERAL_MAX_PAGES;
vzptr->MinPages = VM_GENERAL_MIN_PAGES;
vzptr->InitialPages = VM_GENERAL_INITIAL_PAGES;
vzptr->ExtendPages = VM_GENERAL_EXTEND_PAGES;
vzptr->LogicalName = WASD_VM_GENERAL;
vzptr->ReportTitle = "General";
VmSetPages (vzptr);
/* create the general virtual memory zone */
status = lib$create_vm_zone (&vzptr->ZoneId,
&Algorithm, &AlgorithmArg, &Flags,
&vzptr->ExtendPages,
&vzptr->InitialPages,
&BlockBytes, 0, 0, 0, &ZoneNameDsc, 0, 0);
if (VMSnok (status))
ErrorExitVmsStatus (status, "lib$create_vm_zone()", FI_LI);
}
/*****************************************************************************/
/*
Allocate memory for general use.
*/
uchar* VmGet (ulong ChunkSize)
{
int status;
ulong BaseAddress;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM, "VmGet() !UL", ChunkSize);
return (VmGenericCalloc (&VmGeneralZone, 1, ChunkSize, FI_LI));
}
/*****************************************************************************/
/*
Expand (or even contract) an individual a general-use chunk. See VmGet().
*/
uchar* VmRealloc
(
uchar *ChunkPtr,
ulong ChunkSize,
char *ModuleName,
int LineNumber
)
{
/*********/
/* begin */
/*********/
return (VmGenericRealloc (&VmGeneralZone, ChunkPtr, ChunkSize,
ModuleName, LineNumber));
}
/*****************************************************************************/
/*
Release memory allocated for general use.
*/
void VmFree
(
uchar *ChunkPtr,
char *ModuleName,
int LineNumber
)
{
/*********/
/* begin */
/*********/
VmGenericFree (&VmGeneralZone, ChunkPtr, ModuleName, LineNumber);
}
/*****************************************************************************/
/*
Initialize the virtual memory zone for the request structures.
*/
void VmRequestInit ()
{
static $DESCRIPTOR (ZoneNameDsc, "WASD Request Pool");
static ulong Algorithm = LIB$K_VM_QUICK_FIT,
AlgorithmArg = 32,
Flags = LIB$M_VM_BOUNDARY_TAGS |
LIB$M_VM_GET_FILL0 |
LIB$M_VM_TAIL_LARGE,
BlockBytes = VM_BLOCK_BYTES;
int status;
ulong ExtendPages, InitialPages;
char *cptr;
VM_ZONE *vzptr = &VmRequestZone;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM,
"VmRequestInit() !UL", NetConcurrentMax);
/* not used in this function - used in VmGetRequest() */
vzptr->MagicValue = 0;
vzptr->MaxPages = VM_REQUEST_MAX_PAGES;
vzptr->MinPages = VM_REQUEST_MIN_PAGES;
vzptr->InitialPages = VM_REQUEST_INITIAL_PAGES;
vzptr->ExtendPages = VM_REQUEST_EXTEND_PAGES;
vzptr->TuneSample = VM_REQUEST_TUNE_SAMPLE;
vzptr->TunePeriod = VM_REQUEST_TUNE_PERIOD;
vzptr->LogicalName = WASD_VM_REQUEST;
vzptr->ReportTitle = "Request";
VmSetPages (vzptr);
ExtendPages = InitialPages =
((NetConcurrentMax * RequestStructSize) / 512) + 1;
/* create the virtual memory zone for the request pool */
status = lib$create_vm_zone (&vzptr->ZoneId,
&Algorithm, &AlgorithmArg, &Flags,
&ExtendPages, &InitialPages, &BlockBytes,
0, 0, 0, &ZoneNameDsc, 0, 0);
if (VMSnok (status))
ErrorExitVmsStatus (status, "lib$create_vm_zone()", FI_LI);
FaoToStdout ("%HTTPD-I-VM, request zone initialised\n");
}
/*****************************************************************************/
/*
Allocate a request structure with associated virtual memory zone ready for
heap allocation.
*/
REQUEST_STRUCT* VmGetRequest (int ConnectNumber)
{
static $DESCRIPTOR (ProctorZoneNameFaoDsc, "WASD Proctor Heap !UL");
static $DESCRIPTOR (RequestZoneNameFaoDsc, "WASD Request Heap "
"<a href=\"!AZ?at=!UL\">!-!UL</a>");
static ulong Algorithm = LIB$K_VM_QUICK_FIT,
AlgorithmArg = 16,
Flags = LIB$M_VM_BOUNDARY_TAGS |
LIB$M_VM_GET_FILL0 |
LIB$M_VM_TAIL_LARGE,
BlockBytes = VM_BLOCK_BYTES;
int status;
ushort slen;
ulong BaseAddress,
InitialPages;
char ZoneName [128];
REQUEST_STRUCT *rqptr;
$DESCRIPTOR (ZoneNameDsc, ZoneName);
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM, "VmGetRequest()");
if (ConnectNumber > 0)
status = sys$fao (&RequestZoneNameFaoDsc, &slen, &ZoneNameDsc,
ADMIN_REPORT_WATCH, ConnectNumber);
else
status = sys$fao (&ProctorZoneNameFaoDsc, &slen, &ZoneNameDsc,
-(ConnectNumber));
if (VMSnok (status)) ErrorExitVmsStatus (status, "sys$fao()", FI_LI);
ZoneName[slen] = '\0';
ZoneNameDsc.dsc$w_length = slen;
status = lib$get_vm (&RequestStructSize, &BaseAddress,
&VmRequestZone.ZoneId);
if (VMSnok (status)) ErrorExitVmsStatus (status, "lib$get_vm()", FI_LI);
rqptr = (REQUEST_STRUCT*)BaseAddress;
rqptr->ConnectNumber = ConnectNumber;
if (!(InitialPages = VmRequestZone.StatInitial))
InitialPages = VmRequestZone.InitialPages;
/* now create a virtual memory zone for the request's heap */
rqptr->VmHeapZoneId = 0;
status = lib$create_vm_zone (&rqptr->VmHeapZoneId,
&Algorithm, &AlgorithmArg, &Flags,
&VmRequestZone.ExtendPages, &InitialPages,
&BlockBytes, 0, 0, 0, &ZoneNameDsc, 0, 0);
if (VMSnok (status))
ErrorExitVmsStatus (status, "lib$create_vm_zone()", FI_LI);
return (rqptr);
}
/*****************************************************************************/
/*
Delete any virtual memory zone created for the request's heap, then return the
request structure to the request virtual memory pool.
*/
void VmFreeRequest
(
REQUEST_STRUCT *rqptr,
char *ModuleName,
int LineNumber
)
{
static ulong PrevByteCount;
int status;
ulong PageCount;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_VM))
WatchThis (WATCHITM(rqptr), WATCH_MOD_VM, "VmFreeRequest()");
if (rqptr->VmHeapZoneId)
{
/* delete the request's heap's virtual memory zone */
status = lib$delete_vm_zone (&rqptr->VmHeapZoneId);
if (VMSnok (status))
ErrorExitVmsStatus (status, "lib$delete_vm_zone()", FI_LI);
}
status = lib$free_vm (0, &rqptr, &VmRequestZone.ZoneId);
if (VMSnok (status))
ErrorExitVmsStatus (status, "VmFreeRequest() lib$free_vm()",
ModuleName, LineNumber);
}
/*****************************************************************************/
/*
Allocate dynamic memory to an individual request's heap. Return a pointer to
the start of new *usable* memory area if successful, explode if not.
*/
uchar* VmGetHeap
(
REQUEST_STRUCT *rqptr,
ulong ChunkSize
)
{
int status;
ulong BaseAddress;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_VM))
WatchThis (WATCHITM(rqptr), WATCH_MOD_VM, "VmGetHeap() !UL", ChunkSize);
ChunkSize += VM_ALLOC_OVERHEAD;
status = lib$get_vm (&ChunkSize, &BaseAddress, &rqptr->VmHeapZoneId);
if (VMSnok (status)) ErrorExitVmsStatus (status, "lib$get_vm()", FI_LI);
ChunkSize -= VM_ALLOC_OVERHEAD;
((VM_STRUCT*)BaseAddress)->size = ChunkSize;
((VM_STRUCT*)BaseAddress)->magic = VM_MAGIC_REQUEST;
return ((uchar*)BaseAddress + sizeof(VM_STRUCT));
}
/*****************************************************************************/
/*
Expand (or even contract) an individual chunk. See VmGetHeap().
*/
uchar* VmReallocHeap
(
REQUEST_STRUCT *rqptr,
uchar *ChunkPtr,
ulong ChunkSize,
char *ModuleName,
int LineNumber
)
{
int status;
ulong BaseAddress,
TheBaseAddress,
TheChunkSize;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_VM))
{
if (ChunkPtr)
TheChunkSize = ((VM_STRUCT*)(ChunkPtr-sizeof(VM_STRUCT)))->size;
else
TheChunkSize = 0;
WatchThis (WATCHITM(rqptr), WATCH_MOD_VM,
"VmReallocHeap() !UL !UL", TheChunkSize, ChunkSize);
}
if (!ChunkPtr) return (VmGetHeap (rqptr, ChunkSize));
TheBaseAddress = ChunkPtr - sizeof(VM_STRUCT);
if (((VM_STRUCT*)TheBaseAddress)->magic != VM_MAGIC_REQUEST)
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck,
ModuleName, LineNumber);
/* if this chunk satisfies the reallocation then just return it */
TheChunkSize = ((VM_STRUCT*)TheBaseAddress)->size;
if (TheChunkSize >= ChunkSize) return (ChunkPtr);
/* allocate a new, larger chunk */
ChunkSize += VM_ALLOC_OVERHEAD;
status = lib$get_vm (&ChunkSize, &BaseAddress, &rqptr->VmHeapZoneId);
if (VMSnok (status))
ErrorExitVmsStatus (status, "VmReallocHeap() lib$get_vm()",
ModuleName, LineNumber);
ChunkSize -= VM_ALLOC_OVERHEAD;
/* copy the existing chunk into the new chunk */
if (TheChunkSize > 0)
memcpy ((uchar*)BaseAddress,
(uchar*)TheBaseAddress,
TheChunkSize + VM_ALLOC_OVERHEAD);
/* update the chunk size */
((VM_STRUCT*)BaseAddress)->size = ChunkSize;
/* free the previous chunk */
status = lib$free_vm (0, &TheBaseAddress, &rqptr->VmHeapZoneId);
if (VMSnok (status))
ErrorExitVmsStatus (status, "VmReallocHeap() lib$free_vm()",
ModuleName, LineNumber);
return ((uchar*)BaseAddress+sizeof(VM_STRUCT));
}
/*****************************************************************************/
/*
Release back into the virtual memory zone one chunk of request heap memory.
*/
void VmFreeFromHeap
(
REQUEST_STRUCT *rqptr,
uchar *ChunkPtr,
char *SourceModuleName,
int SourceLineNumber
)
{
int status,
ChunkSize;
ulong BaseAddress;
/*********/
/* begin */
/*********/
BaseAddress = ChunkPtr - sizeof(VM_STRUCT);
ChunkSize = ((VM_STRUCT*)(BaseAddress))->size;
if (WATCHMOD (rqptr, WATCH_MOD_VM))
WatchThis (WATCHITM(rqptr), WATCH_MOD_VM,
"VmFreeFromHeap() !UL", ChunkSize);
if (((VM_STRUCT*)BaseAddress)->magic != VM_MAGIC_REQUEST)
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck,
SourceModuleName, SourceLineNumber);
status = lib$free_vm (0, &BaseAddress, &rqptr->VmHeapZoneId);
if (VMSnok (status))
ErrorExitVmsStatus (status, "VmFreeFromHeap() lib$free_vm()",
SourceModuleName, SourceLineNumber);
}
/*****************************************************************************/
/*
Release back into the virtual memory zone the individually allocated chunks of
memory (the zone is deleted on request structure release).
*/
void VmFreeHeap
(
REQUEST_STRUCT *rqptr,
char *SourceModuleName,
int SourceLineNumber
)
{
static ulong ShowVmZoneDetail = 1;
int status;
ulong pages;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_VM))
WatchThis (WATCHITM(rqptr), WATCH_MOD_VM, "VmFreeHeap()");
if (VmRequestZone.TuneSample)
{
/********/
/* tune */
/********/
status = lib$show_vm_zone (&rqptr->VmHeapZoneId, &ShowVmZoneDetail,
&VmFreeHeapStat, rqptr);
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
if (rqptr->VmHeapStatPages > 0)
{
VmRequestZone.StatCount++;
VmRequestZone.StatPages += rqptr->VmHeapStatPages;
if (VmRequestZone.StatCount > VmRequestZone.TuneSample)
{
/* after an initial sample of request pages */
VmRequestZone.StatInitial = VmRequestZone.StatPages /
VmRequestZone.StatCount;
VmRequestZone.StatInitial /= VmRequestZone.InitialPages;
VmRequestZone.StatInitial *= VmRequestZone.InitialPages;
if (VmRequestZone.StatInitial > VmRequestZone.MaxPages)
VmRequestZone.StatInitial = VmRequestZone.MaxPages;
/* reset the tuning process after a given number of requests */
if (VmRequestZone.StatCount > VmRequestZone.TuneSample *
VmRequestZone.TunePeriod)
VmRequestZone.StatCount = VmRequestZone.StatPages =
VmRequestZone.StatInitial = 0;
}
rqptr->VmHeapStatPages = 0;
}
}
/********/
/* free */
/********/
/* well - reset, if we must be pedantic */
status = lib$reset_vm_zone (&rqptr->VmHeapZoneId);
if (VMSnok (status))
ErrorExitVmsStatus (status, "VmFreeHeap() lib$reset_vm_zone()",
SourceModuleName, SourceLineNumber);
}
/*****************************************************************************/
/*
Parse the output from lib$show_vm_zone() to determine how many pages were
allocated to the request heap. This value can then be used to optimise request
heap initial allocation. Kludgy but there is (still) no lib$stat_vm_zone().
*/
int VmFreeHeapStat
(
struct dsc$descriptor *DscPtr,
REQUEST_STRUCT *rqptr
)
{
char *cptr, *czptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM, "VmFreeHeapStat() !UL !-!#AZ",
DscPtr->dsc$w_length, DscPtr->dsc$a_pointer);
if (rqptr->VmHeapStatPages ||
DscPtr->dsc$w_length < 60 ||
DscPtr->dsc$w_length > 90) return (SS$_NORMAL);
for (czptr = (cptr = DscPtr->dsc$a_pointer) + DscPtr->dsc$w_length;
cptr < czptr;
cptr++)
if (*cptr == 'I' && MATCH12(cptr,"Initial size")) break;
if (cptr < czptr)
for (cptr += 12; cptr < czptr; cptr++)
if (*cptr == 'C' && MATCH12(cptr,"Current size"))
break;
if (cptr < czptr)
{
cptr += 15;
rqptr->VmHeapStatPages = atol(cptr);
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM, "!SL", rqptr->VmHeapStatPages);
}
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
Initialize the virtual memory zone for the pool of HTTP/2 structures.
*/
void VmHttp2Init ()
{
static $DESCRIPTOR (ZoneNameDsc, "WASD HTTP/2 Pool");
static ulong Algorithm = LIB$K_VM_QUICK_FIT,
AlgorithmArg = 32,
Flags = LIB$M_VM_BOUNDARY_TAGS |
LIB$M_VM_GET_FILL0 |
LIB$M_VM_TAIL_LARGE,
BlockBytes = VM_BLOCK_BYTES;
int status;
ulong ExtendPages, InitialPages;
char *cptr;
VM_ZONE *vzptr = &VmHttp2Zone;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM,
"VmHttp2Init() !UL", NetConcurrentMax);
/* not used in this function - used in VmHttp2Get() */
vzptr->MagicValue = VM_MAGIC_HTTP2;
vzptr->MaxPages = VM_HTTP2_MAX_PAGES;
vzptr->MinPages = VM_HTTP2_MIN_PAGES;
vzptr->InitialPages = VM_HTTP2_INITIAL_PAGES;
vzptr->ExtendPages = VM_HTTP2_EXTEND_PAGES;
vzptr->LogicalName = WASD_VM_HTTP2;
vzptr->ReportTitle = "HTTP/2";
VmSetPages (vzptr);
ExtendPages = InitialPages = (NetConcurrentMax / 10) * 16;
/* create the HTTP/2 virtual memory zone */
status = lib$create_vm_zone (&vzptr->ZoneId,
&Algorithm, &AlgorithmArg, &Flags,
&ExtendPages, &InitialPages,
&BlockBytes, 0, 0, 0, &ZoneNameDsc, 0, 0);
if (VMSnok (status))
ErrorExitVmsStatus (status, "lib$create_vm_zone()", FI_LI);
FaoToStdout ("%HTTPD-I-VM, HTTP/2 zone initialised\n");
}
/*****************************************************************************/
/*
Allocate an HTTP/2 structure with associated virtual memory zone ready for
HTTP/2 heap allocation. This is used almost exclusively for write buffers.
*/
HTTP2_STRUCT* VmHttp2Get (int ConnectNumber)
{
static $DESCRIPTOR (ZoneNameFaoDsc,
"WASD HTTP/2 Heap <a href=\"!AZ?at=!UL\">!-!UL</a>");
static ulong Algorithm = LIB$K_VM_QUICK_FIT,
AlgorithmArg = 16,
Flags = LIB$M_VM_BOUNDARY_TAGS |
LIB$M_VM_GET_FILL0 |
LIB$M_VM_TAIL_LARGE,
BlockBytes = VM_BLOCK_BYTES;
int status;
ushort slen;
ulong BaseAddress;
char ZoneName [128];
HTTP2_STRUCT *h2ptr;
$DESCRIPTOR (ZoneNameDsc, ZoneName);
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM, "VmHttp2Get()");
status = sys$fao (&ZoneNameFaoDsc, &slen, &ZoneNameDsc,
ADMIN_REPORT_WATCH, ConnectNumber);
if (VMSnok (status)) ErrorExitVmsStatus (status, "sys$fao()", FI_LI);
ZoneName[slen] = '\0';
ZoneNameDsc.dsc$w_length = slen;
status = lib$get_vm (&Http2StructSize, &BaseAddress, &VmHttp2Zone.ZoneId);
if (VMSnok (status)) ErrorExitVmsStatus (status, "lib$get_vm()", FI_LI);
h2ptr = (HTTP2_STRUCT*)BaseAddress;
h2ptr->ConnectNumber = ConnectNumber;
/* now create a virtual memory zone for the request's heap */
h2ptr->VmHeapZoneId = 0;
status = lib$create_vm_zone (&h2ptr->VmHeapZoneId,
&Algorithm, &AlgorithmArg, &Flags,
&VmHttp2Zone.ExtendPages,
&VmHttp2Zone.InitialPages,
&BlockBytes, 0, 0, 0, &ZoneNameDsc, 0, 0);
if (VMSnok (status))
ErrorExitVmsStatus (status, "lib$create_vm_zone()", FI_LI);
return (h2ptr);
}
/*****************************************************************************/
/*
Delete any virtual memory zone created for the HTTP/2 heap, then return the
HTTP/2 structure to the request virtual memory pool.
*/
void VmHttp2Free
(
HTTP2_STRUCT *h2ptr,
char *SourceModuleName,
int SourceLineNumber
)
{
static ulong PrevByteCount;
int status;
ulong PageCount;
/*********/
/* begin */
/*********/
if (WATCHMOD (h2ptr, WATCH_MOD_VM))
WatchThis (WATCHITM(h2ptr), WATCH_MOD_VM, "VmHttp2Free()");
if (h2ptr->VmHeapZoneId)
{
/* delete the request's heap's virtual memory zone */
status = lib$delete_vm_zone (&h2ptr->VmHeapZoneId);
if (VMSnok (status))
ErrorExitVmsStatus (status, "lib$delete_vm_zone()", FI_LI);
}
status = lib$free_vm (0, &h2ptr, &VmHttp2Zone.ZoneId);
if (VMSnok (status))
ErrorExitVmsStatus (status, "VmHttp2Free() lib$free_vm()",
SourceModuleName, SourceLineNumber);
}
/*****************************************************************************/
/*
Allocate dynamic memory to an individual HTTP/2 heap. Return a pointer to
the start of new *usable* memory area if successful, explode if not.
*/
uchar* VmGet2Heap
(
HTTP2_STRUCT *h2ptr,
ulong ChunkSize
)
{
int status;
ulong BaseAddress;
/*********/
/* begin */
/*********/
if (WATCHMOD (h2ptr, WATCH_MOD_VM))
WatchThis (WATCHITM(h2ptr), WATCH_MOD_VM, "VmGet2Heap() !UL", ChunkSize);
ChunkSize += VM_ALLOC_OVERHEAD;
status = lib$get_vm (&ChunkSize, &BaseAddress, &h2ptr->VmHeapZoneId);
if (VMSnok (status)) ErrorExitVmsStatus (status, "lib$get_vm()", FI_LI);
ChunkSize -= VM_ALLOC_OVERHEAD;
((VM_STRUCT*)BaseAddress)->size = ChunkSize;
((VM_STRUCT*)BaseAddress)->magic = VM_MAGIC_HTTP2;
return ((uchar*)BaseAddress+sizeof(VM_STRUCT));
}
/*****************************************************************************/
/*
Release back into the virtual memory zone one chunk of HTTP/2 heap memory.
*/
void VmFreeFrom2Heap
(
HTTP2_STRUCT *h2ptr,
uchar *ChunkPtr,
char *SourceModuleName,
int SourceLineNumber
)
{
int status,
ChunkSize;
ulong BaseAddress;
/*********/
/* begin */
/*********/
BaseAddress = ChunkPtr - sizeof(VM_STRUCT);
ChunkSize = ((VM_STRUCT*)(BaseAddress))->size;
if (WATCHMOD (h2ptr, WATCH_MOD_VM))
WatchThis (WATCHITM(h2ptr), WATCH_MOD_VM,
"VmFreeFrom2Heap() !UL", ChunkSize);
if (((VM_STRUCT*)BaseAddress)->magic != VM_MAGIC_HTTP2)
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck,
SourceModuleName, SourceLineNumber);
status = lib$free_vm (0, &BaseAddress, &h2ptr->VmHeapZoneId);
if (VMSnok (status))
ErrorExitVmsStatus (status, "VmFreeFrom2Heap() lib$free_vm()",
SourceModuleName, SourceLineNumber);
}
/*****************************************************************************/
/*
Release back into the HTTP/2 virtual memory zone the individually allocated
chunks of memory (the zone is deleted on request structure release).
*/
void VmFree2Heap
(
HTTP2_STRUCT *h2ptr,
char *SourceModuleName,
int SourceLineNumber
)
{
int status;
/*********/
/* begin */
/*********/
if (WATCHMOD (h2ptr, WATCH_MOD_VM))
WatchThis (WATCHITM(h2ptr), WATCH_MOD_VM, "VmFree2Heap()");
status = lib$reset_vm_zone (&h2ptr->VmHeapZoneId);
if (VMSnok (status))
ErrorExitVmsStatus (status, "VmFree2Heap() lib$reset_vm_zone()",
SourceModuleName, SourceLineNumber);
}
/*****************************************************************************/
/*
Initialize the virtual memory zone cache memory will be allocated from.
*/
void VmCacheInit (int TotalKBytesMax)
{
static $DESCRIPTOR (ZoneNameDsc, "WASD Cache");
static ulong Algorithm = LIB$K_VM_QUICK_FIT,
AlgorithmArg = 128,
Flags = LIB$M_VM_BOUNDARY_TAGS |
LIB$M_VM_GET_FILL0 |
LIB$M_VM_TAIL_LARGE,
ExtendPages,
InitialPages,
BlockBytes = VM_BLOCK_BYTES;
int status;
VM_ZONE *vzptr = &VmCacheZone;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM,
"VmCacheInit() !UL", TotalKBytesMax);
vzptr->MagicValue = VM_MAGIC_CACHE;
vzptr->MaxPages = VM_CACHE_MAX_PAGES;
vzptr->MinPages = VM_CACHE_MIN_PAGES;
vzptr->InitialPages = VM_CACHE_INITIAL_PAGES;
vzptr->ExtendPages = VM_CACHE_EXTEND_PAGES;
vzptr->LogicalName = WASD_VM_CACHE;
vzptr->ReportTitle = "Cache";
VmSetPages (vzptr);
if ((InitialPages = TotalKBytesMax * 2) <= 0) InitialPages = 32;
ExtendPages = InitialPages / 2;
/* create the cache virtual memory zone */
status = lib$create_vm_zone (&vzptr->ZoneId,
&Algorithm, &AlgorithmArg, &Flags,
&ExtendPages, &InitialPages, &BlockBytes,
0, 0, 0, &ZoneNameDsc, 0, 0);
if (VMSnok (status))
ErrorExitVmsStatus (status, "lib$create_vm_zone()", FI_LI);
FaoToStdout ("%HTTPD-I-VM, cache zone initialised\n");
}
/*****************************************************************************/
/*
*/
uchar* VmGetCache (ulong ChunkSize)
{
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM,
"VmGetCache() !UL", ChunkSize);
if (!VmCacheZone.ZoneId) VmCacheInit (CacheTotalKBytesMax);
return (VmGenericCalloc (&VmCacheZone, 1, ChunkSize, FI_LI));
}
/*****************************************************************************/
/*
Release back into the virtual memory zone the individually allocated chunks of
cache memory.
*/
void VmFreeCache
(
uchar *ChunkPtr,
char *ModuleName,
int LineNumber
)
{
/*********/
/* begin */
/*********/
VmGenericFree (&VmCacheZone, ChunkPtr, ModuleName, LineNumber);
}
/*****************************************************************************/
/*
Initialize the virtual memory zone permanent cache memory will be allocated
from.
*/
void VmPermCacheInit (int TotalKBytesMax)
{
static $DESCRIPTOR (ZoneNameDsc, "WASD Perm-Cache");
static ulong Algorithm = LIB$K_VM_QUICK_FIT,
AlgorithmArg = 128,
Flags = LIB$M_VM_BOUNDARY_TAGS |
LIB$M_VM_GET_FILL0 |
LIB$M_VM_TAIL_LARGE,
ExtendPages,
InitialPages,
BlockBytes = VM_BLOCK_BYTES;
int status;
VM_ZONE *vzptr = &VmPermCacheZone;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM,
"VmPermCacheInit() !UL", TotalKBytesMax);
vzptr->MagicValue = VM_MAGIC_PERMCACHE;
vzptr->MaxPages = VM_PERMCACHE_MAX_PAGES;
vzptr->MinPages = VM_PERMCACHE_MIN_PAGES;
vzptr->InitialPages = VM_PERMCACHE_INITIAL_PAGES;
vzptr->ExtendPages = VM_PERMCACHE_EXTEND_PAGES;
vzptr->LogicalName = WASD_VM_PERMCACHE;
vzptr->ReportTitle = "Permanent Cache";
VmSetPages (vzptr);
if ((InitialPages = TotalKBytesMax * 2) <= 0) InitialPages = 32;
ExtendPages = InitialPages / 2;
/* create the cache virtual memory zone */
status = lib$create_vm_zone (&vzptr->ZoneId,
&Algorithm, &AlgorithmArg, &Flags,
&ExtendPages, &InitialPages, &BlockBytes,
0, 0, 0, &ZoneNameDsc, 0, 0);
if (VMSnok (status))
ErrorExitVmsStatus (status, "lib$create_vm_zone()", FI_LI);
FaoToStdout ("%HTTPD-I-VM, permanent cache zone initialised\n");
}
/*****************************************************************************/
/*
*/
uchar* VmGetPermCache (ulong ChunkSize)
{
int status;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM,
"VmGetPermCache() !UL", ChunkSize);
if (!VmPermCacheZone.ZoneId) VmPermCacheInit (CacheTotalKBytesMax);
return (VmGenericCalloc (&VmPermCacheZone, 1, ChunkSize, FI_LI));
}
/*****************************************************************************/
/*
Release back into the virtual memory zone the individually allocated chunks of
permanent cache memory.
*/
void VmFreePermCache
(
uchar *ChunkPtr,
char *ModuleName,
int LineNumber
)
{
/*********/
/* begin */
/*********/
VmGenericFree (&VmPermCacheZone, ChunkPtr, ModuleName, LineNumber);
}
/*****************************************************************************/
/*
Once a minute HttpdTick() calls this function to check how much page file (and
hence virtual memory) has been consumed. When the default limit has been
exceeded the server proactively exits with an explanatory message. The logical
name WASD_VM_PGFL_LIMIT defined as an integer 20..99 can change the default
percentage. The rationale is that it's better to elegantly exit for a known
reason than spit somewhere less obvious because memory wasn't available.
*/
void VmCheckPgFlLimit ()
{
static ulong JpiPagFilCnt,
JpiPgFlQuo;
static VMS_ITEM_LIST3
JpiItems [] =
{
{ sizeof(JpiPagFilCnt), JPI$_PAGFILCNT, &JpiPagFilCnt, 0 },
{ sizeof(JpiPgFlQuo), JPI$_PGFLQUOTA, &JpiPgFlQuo, 0 },
{ 0,0,0,0 }
};
int limit, percent, status;
char *cptr;
char buf [64];
IO_SB IOsb;
/*********/
/* begin */
/*********/
limit = VM_DEFAULT_PGFL_LIMIT;
if (cptr = SysTrnLnm (WASD_VM_PGFL_LIMIT))
{
limit = atoi(cptr);
if (limit < 20 || limit > 99) limit = VM_DEFAULT_PGFL_LIMIT;
}
status = sys$getjpiw (EfnWait, 0, 0, &JpiItems, &IOsb, 0, 0);
if (VMSok (status)) status = IOsb.Status;
if (VMSnok (status)) ErrorExitVmsStatus (status, NULL, FI_LI);
percent = 0;
if (JpiPagFilCnt) percent = 100 - PercentOf32(JpiPagFilCnt, JpiPgFlQuo);
if (percent > limit)
{
sprintf (buf, "current page file usage %d%% exceeds %d%% limit",
percent, limit);
ErrorExitVmsStatus (SS$_ABORT, buf, FI_LI);
}
}
/*****************************************************************************/
/*
Initialize the virtual memory zone DECC malloc(), calloc(), realloc() (and
free()) memory will be allocated from.
*/
#if VM_DECC
void VmDeccInit ()
{
static $DESCRIPTOR (ZoneNameDsc, "WASD DECC");
static ulong Algorithm = LIB$K_VM_QUICK_FIT,
AlgorithmArg = 64,
Flags = LIB$M_VM_BOUNDARY_TAGS |
LIB$M_VM_GET_FILL0 |
LIB$M_VM_TAIL_LARGE,
BlockBytes = VM_BLOCK_BYTES;
int status;
char *cptr;
int64 Time64;
VM_ZONE *vzptr = &VmDeccZone;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM, "VmDeccInit()");
/* we may have to conjure up our own time */
if (!HttpdTickSecond) HttpdTickSecond = HttpdGetTickSecond();
/* for the next 10 seconds DECC has a get-out-of-jail-free card */
VmDeccTickSecond = HttpdTickSecond + 10;
if (vzptr->ZoneId) return;
vzptr->MagicValue = VM_MAGIC_DECC;
vzptr->MaxPages = VM_DECC_MAX_PAGES;
vzptr->MinPages = VM_DECC_MIN_PAGES;
vzptr->InitialPages = VM_DECC_INITIAL_PAGES;
vzptr->ExtendPages = VM_DECC_EXTEND_PAGES;
vzptr->LogicalName = WASD_VM_DECC;
vzptr->ReportTitle = "DECC";
VmSetPages (vzptr);
#if !VM_DECC_LIB_VM
/* forced disable of zone-based memory management */
vzptr->ZoneId = (int)-1;
#endif
/* if zone-based memory management disabled */
if ((int)vzptr->ZoneId < 0) return;
/* create the general virtual memory zone */
status = lib$create_vm_zone (&vzptr->ZoneId,
&Algorithm, &AlgorithmArg, &Flags,
&vzptr->ExtendPages,
&vzptr->InitialPages,
&BlockBytes, 0, 0, 0, &ZoneNameDsc, 0, 0);
if (VMSnok (status))
ErrorExitVmsStatus (status, "lib$create_vm_zone()", FI_LI);
if (HttpdServerStartup)
FaoToStdout ("%HTTPD-I-VM, DECC zone initialised\n");
}
#endif /* VM_DECC */
/*****************************************************************************/
/*
Allocate memory for DECC use.
*/
#if VM_DECC
void* VmDeccCalloc
(
int NumChunks,
int ChunkSize
)
{
/*********/
/* begin */
/*********/
if (!VmDeccZone.ZoneId) VmDeccInit ();
return (VmGenericCalloc (&VmDeccZone, NumChunks, ChunkSize, FI_LI));
}
#endif /* VM_DECC */
/*****************************************************************************/
/*
A wrapper for malloc() which just uses calloc().
*/
#if VM_DECC
void* VmDeccMalloc (int ChunkSize)
{
/*********/
/* begin */
/*********/
if (!VmDeccZone.ZoneId) VmDeccInit ();
return (VmGenericCalloc (&VmDeccZone, -1, ChunkSize, FI_LI));
}
#endif /* VM_DECC */
/*****************************************************************************/
/*
Expand an individual a DECC chunk.
See VmDeccCalloc().
*/
#if VM_DECC
void* VmDeccRealloc
(
uchar *ChunkPtr,
int ChunkSize
)
{
/*********/
/* begin */
/*********/
if (!VmDeccZone.ZoneId) VmDeccInit ();
return (VmGenericRealloc (&VmDeccZone, ChunkPtr, ChunkSize, FI_LI));
}
#endif /* VM_DECC */
/*****************************************************************************/
/*
Release memory allocated for DECC use.
*/
#if VM_DECC
void VmDeccFree (uchar *ChunkPtr)
{
/*********/
/* begin */
/*********/
if (!VmDeccZone.ZoneId) VmDeccInit ();
VmGenericFree (&VmDeccZone, ChunkPtr, FI_LI);
}
#endif /* VM_DECC */
/*****************************************************************************/
/*
Initialise virtual memory management for EXPAT.
*/
#if VM_EXPAT
BOOL VmExpatInit ()
{
static $DESCRIPTOR (ZoneNameDsc, "WASD expat");
static ulong Algorithm = LIB$K_VM_QUICK_FIT,
AlgorithmArg = 64,
Flags = LIB$M_VM_BOUNDARY_TAGS |
LIB$M_VM_TAIL_LARGE,
BlockBytes = VM_BLOCK_BYTES;
int status;
char *cptr;
VM_ZONE *vzptr = &VmExpatZone;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM, "VmExpatInit()");
if ((int)vzptr->ZoneId < 0) return (false);
vzptr->MagicValue = VM_MAGIC_EXPAT;
vzptr->MaxPages = VM_EXPAT_MAX_PAGES;
vzptr->MinPages = VM_EXPAT_MIN_PAGES;
vzptr->InitialPages = VM_EXPAT_INITIAL_PAGES;
vzptr->ExtendPages = VM_EXPAT_EXTEND_PAGES;
vzptr->LogicalName = WASD_VM_EXPAT;
vzptr->ReportTitle = "EXPAT";
VmSetPages (vzptr);
/* if zone-based memory management disabled */
if (vzptr->ZoneId == (ulong)-1) return (false);
/* create the expat virtual memory zone */
status = lib$create_vm_zone (&vzptr->ZoneId,
&Algorithm, &AlgorithmArg, &Flags,
&vzptr->ExtendPages,
&vzptr->InitialPages,
&BlockBytes, 0, 0, 0, &ZoneNameDsc, 0, 0);
if (VMSnok (status))
ErrorExitVmsStatus (status, "lib$create_vm_zone()", FI_LI);
FaoToStdout ("%HTTPD-I-VM, EXPAT zone initialised\n");
return (true);
}
#else /* VM_EXPAT */
/******************/
/* NOT VM_EXPAT */
/******************/
BOOL VmExpatInit () { return (false); }
/* allow ExpatInit() linkages without recompile */
void* VmExpatMalloc (int ChunkSize) { return (NULL); }
void* VmExpatRealloc (uchar *ChunkPtr, int ChunkSize ) { return (NULL); }
void VmExpatFree (uchar *ChunkPtr) { return; }
#endif /* VM_EXPAT */
/*****************************************************************************/
/*
Allocate memory for EXPAT use.
*/
#if VM_EXPAT
void* VmExpatMalloc (int ChunkSize)
{
/*********/
/* begin */
/*********/
return (VmGenericCalloc (&VmExpatZone, -1, ChunkSize, FI_LI));
}
#endif /* VM_EXPAT */
/*****************************************************************************/
/*
Expand an individual EXPAT chunk. See VmGenericCalloc().
*/
#if VM_EXPAT
void* VmExpatRealloc
(
uchar *ChunkPtr,
int ChunkSize
)
{
/*********/
/* begin */
/*********/
return (VmGenericRealloc (&VmExpatZone, ChunkPtr, ChunkSize, FI_LI));
}
#endif /* VM_EXPAT */
/*****************************************************************************/
/*
Release memory allocated for EXPAT use.
*/
#if VM_EXPAT
void VmExpatFree (uchar *ChunkPtr)
{
/*********/
/* begin */
/*********/
VmGenericFree (&VmExpatZone, ChunkPtr, FI_LI);
}
#endif /* VM_EXPAT */
/*****************************************************************************/
/*
Initialise virtual memory management for OpenSSL.
*/
#if VM_OPENSSL
BOOL VmOpenSslInit ()
{
static $DESCRIPTOR (ZoneNameDsc, "WASD OpenSSL");
static ulong Algorithm = LIB$K_VM_QUICK_FIT,
AlgorithmArg = 128,
Flags = LIB$M_VM_BOUNDARY_TAGS |
LIB$M_VM_TAIL_LARGE,
BlockBytes = VM_BLOCK_BYTES;
int status;
char *cptr;
VM_ZONE *vzptr = &VmOpenSslZone;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM, "VmOpenSslInit()");
if ((int)vzptr->ZoneId < 0) return (false);
vzptr->MagicValue = VM_MAGIC_OPENSSL;
vzptr->MaxPages = VM_OPENSSL_MAX_PAGES;
vzptr->MinPages = VM_OPENSSL_MIN_PAGES;
vzptr->InitialPages = VM_OPENSSL_INITIAL_PAGES;
vzptr->ExtendPages = VM_OPENSSL_EXTEND_PAGES;
vzptr->LogicalName = WASD_VM_OPENSSL;
vzptr->ReportTitle = "OpenSSL";
VmSetPages (vzptr);
/* if zone-based memory management disabled */
if (vzptr->ZoneId == (ulong)-1) return (false);
/* create the OpenSSL virtual memory zone */
status = lib$create_vm_zone (&vzptr->ZoneId,
&Algorithm, &AlgorithmArg, &Flags,
&vzptr->ExtendPages,
&vzptr->InitialPages,
&BlockBytes, 0, 0, 0, &ZoneNameDsc, 0, 0);
if (VMSnok (status))
ErrorExitVmsStatus (status, "lib$create_vm_zone()", FI_LI);
FaoToStdout ("%HTTPD-I-VM, OpenSSL zone initialised\n");
return (true);
}
#else /* VM_OPENSSL */
/******************/
/* NOT VM_OPENSSL */
/******************/
BOOL VmOpenSslInit () { return (false); }
/* allow SesolaInit() linkages without recompile */
void* VmOpenSslMalloc (int ChunkSize) { return (NULL); }
void* VmOpenSslRealloc (uchar *ChunkPtr, int ChunkSize ) { return (NULL); }
void VmOpenSslFree (uchar *ChunkPtr) { return; }
#endif /* VM_OPENSSL */
/*****************************************************************************/
/*
Allocate memory for OpenSSL use.
NOTE: OpenSSL does not employ calloc().
*/
#if VM_OPENSSL
void* VmOpenSslMalloc (int ChunkSize)
{
/*********/
/* begin */
/*********/
return (VmGenericCalloc (&VmOpenSslZone, -1, ChunkSize, FI_LI));
}
#endif /* VM_OPENSSL */
/*****************************************************************************/
/*
Expand an individual OpenSSL chunk. See VmGenericCalloc().
*/
#if VM_OPENSSL
void* VmOpenSslRealloc
(
uchar *ChunkPtr,
int ChunkSize
)
{
/*********/
/* begin */
/*********/
return (VmGenericRealloc (&VmOpenSslZone, ChunkPtr, ChunkSize, FI_LI));
}
#endif /* VM_OPENSSL */
/*****************************************************************************/
/*
Release memory allocated for OpenSSL use.
*/
#if VM_OPENSSL
void VmOpenSslFree (uchar *ChunkPtr)
{
/*********/
/* begin */
/*********/
VmGenericFree (&VmOpenSslZone, ChunkPtr, FI_LI);
}
#endif /* VM_OPENSSL */
/*****************************************************************************/
/*
Set initial and extend pages for the zone.
Set initial to -1 to disable *some* VM zones.
Set initial to 0 to enable *some* VM zones and have default values.
Default <integer> values are pages, and if a trailing 'p'. If a trailing 'b'
then indicates bytes, or if 'm' megabytes (or mebibytes if you prefer), and
pages are calculated using <bytes> / 512 plus 5%.
Some zones allow tuning (dynamic adjustment to initial allocation) and will
accept an additional two integers, the initial sample size, and how long that
tune is maintained before reset.
*/
void VmSetPages (VM_ZONE *ZonePtr)
{
long ExtendPages = 0,
InitialPages = 0,
TuneSample = -1,
TunePeriod = -1;
char *cptr;
/*********/
/* begin */
/*********/
sys$gettim (&ZonePtr->LastLookTime64);
/* disabled by default - only some callers pay attention to disabled */
ZonePtr->ZoneId = (ulong)-1;
if (!(cptr = SysTrnLnm (ZonePtr->LogicalName))) return;
/* logical name value should be "<initial>[,extend>]" integers */
while (*cptr && !isdigit(*cptr) && *cptr != '-') cptr++;
InitialPages = atol(cptr);
if (*cptr == '-') cptr++;
while (*cptr && isdigit(*cptr)) cptr++;
if (tolower(*cptr) == 'b' || tolower(*cptr) == 'm')
{
if (InitialPages > 0)
{
if (tolower(*cptr) == 'm') InitialPages *= 1048576;
InitialPages /= 512;
InitialPages += (InitialPages * 5) / 100;
}
while (*cptr && isalpha(*cptr)) cptr++;
}
while (*cptr && !isdigit(*cptr) && *cptr != '-') cptr++;
ExtendPages = atol(cptr);
if (*cptr == '-') cptr++;
while (*cptr && isdigit(*cptr)) cptr++;
if (tolower(*cptr) == 'b' || tolower(*cptr) == 'm')
{
if (ExtendPages > 0)
{
if (tolower(*cptr) == 'm') ExtendPages *= 1048576;
ExtendPages /= 512;
ExtendPages += (ExtendPages * 5) / 100;
}
while (*cptr && isalpha(*cptr)) cptr++;
}
/* value can have optional "[,<tune-sample>[,<tune-period>]" integers */
while (*cptr && !isdigit(*cptr)) cptr++;
if (*cptr) TuneSample = atol(cptr);
while (*cptr && isdigit(*cptr)) cptr++;
while (*cptr && !isdigit(*cptr)) cptr++;
if (*cptr) TunePeriod = atol(cptr);
while (*cptr && isdigit(*cptr)) cptr++;
/* only some callers pay attention to disabled zones */
if (InitialPages >= 0)
{
/* zone-based management enabled */
ZonePtr->ZoneId = 0;
if (!InitialPages) InitialPages = ZonePtr->InitialPages;
if (!ExtendPages) ExtendPages = ZonePtr->ExtendPages;
if (InitialPages > ZonePtr->MaxPages)
InitialPages = ZonePtr->MaxPages;
else
if (InitialPages <= ZonePtr->MinPages)
InitialPages = ZonePtr->MinPages;
ZonePtr->InitialPages = InitialPages;
if (ExtendPages > ZonePtr->MaxPages)
ExtendPages = ZonePtr->MaxPages;
else
if (ExtendPages <= ZonePtr->MinPages)
ExtendPages = ZonePtr->MinPages;
ZonePtr->ExtendPages = ExtendPages;
/* not all zones pay attention to these settings */
if (TuneSample >= 0)
ZonePtr->TuneSample = TuneSample;
else
ZonePtr->TuneSample = VM_REQUEST_TUNE_SAMPLE;
if (TunePeriod >= 0)
ZonePtr->TunePeriod = TunePeriod;
else
ZonePtr->TunePeriod = VM_REQUEST_TUNE_PERIOD;
}
}
/*****************************************************************************/
/*
Return a report on processes' virtual memory usage. This function blocks while
executing.
*/
#define SHOW_VM_64 0
#ifndef SHOW_VM_64
# define SHOW_VM_64 1
#endif
#if SHOW_VM_64
/* prototype */
int VmWrite64 (struct dsc$descriptor*, int64);
#endif
#if VM_BACKPORT_FOR_DTAG /* see VM.H */
void Vm__Report (REQUEST_STRUCT*);
void VmReport (REQUEST_STRUCT *rqptr, REQUEST_AST NextTaskFunction)
{
Vm__Report (rqptr);
SysDclAst (NextTaskFunction, rqptr);
}
void Vm__Report (REQUEST_STRUCT *rqptr)
#else
void VmReport (REQUEST_STRUCT *rqptr)
#endif
{
static ulong ShowVmCode123 = 0,
ShowVmCode567 = 4,
ShowVmZoneDetail = 3;
#if SHOW_VM_64
static int64 ShowVm64Code123 = 0,
ShowVm64Code567 = 4,
ShowVm64ZoneDetail = 3;
#endif /* SHOW_VM_64 */
static char BeginPageFao [] =
"<p><table class=\"ctgry\">\n\
<tr><td>\n\
<table class=\"lftlft\">\n\
<tr><td><pre>\
Request Heap Initial Pages: !UL (!ULkB) <!!-- !UL !UL !&,@SQ/!&,@SQ -->\n\
Extend Pages: !UL (!ULkB)\n\
\n\
HTTP/2 Heap Initial Pages: !UL (!ULkB)\n\
Extend Pages: !UL (!ULkB)\n\
\n\
WsSize: !UL (!ULMB) WsPeak: !UL (!ULMB) VirtPeak: !UL (!ULMB)\n\
\n\
PgFl: !UL/!UL (!UL/!ULMB !UL%)\n\
\n";
static char EndPageFao [] =
"</pre></td></tr>\n\
</table>\n\
</td></tr>\n\
</table>\n\
</body>\n\
</html>\n";
static ulong JpiPageFlts,
JpiPagFilCnt,
JpiVirtPeak,
JpiWsSize,
JpiWsPeak,
Pid = 0;
static VMS_ITEM_LIST3 JpiItems [] =
{
{ sizeof(JpiPageFlts), JPI$_PAGEFLTS, &JpiPageFlts, 0 },
{ sizeof(JpiPagFilCnt), JPI$_PAGFILCNT, &JpiPagFilCnt, 0 },
{ sizeof(JpiVirtPeak), JPI$_VIRTPEAK, &JpiVirtPeak, 0 },
{ sizeof(JpiWsSize), JPI$_WSSIZE, &JpiWsSize, 0 },
{ sizeof(JpiWsPeak), JPI$_WSPEAK, &JpiWsPeak, 0 },
{0,0,0,0}
};
int cnt, status;
ushort Length;
ulong Context,
ZoneId;
char Buffer [4096];
IO_SB IOsb;
$DESCRIPTOR (BufferDsc, Buffer);
#if SHOW_VM_64
int64 Context64,
ZoneId64;
#endif /* SHOW_VM_64 */
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM, "VmReport()");
status = sys$getjpiw (EfnWait, &Pid, 0, &JpiItems, &IOsb, 0, 0);
if (VMSok (status)) status = IOsb.Status;
if (VMSnok (status))
{
rqptr->rqResponse.ErrorTextPtr = "sys$getjpiw()";
ErrorVmsStatus (rqptr, status, FI_LI);
#if !VM_BACKPORT_FOR_DTAG
AdminEnd (rqptr);
#endif
return;
}
VmReportPlus = strsame (rqptr->rqHeader.RequestUriPtr,
ADMIN_REPORT_MEMORY_PLUS, -1);
if (VmReportPlus)
AdminPageTitle (rqptr, "Virtual Memory+ Report");
else
AdminPageTitle (rqptr, "Virtual Memory Report");
status = FaoToNet (rqptr, BeginPageFao,
VmRequestZone.StatInitial ?
VmRequestZone.StatInitial :
VmRequestZone.InitialPages,
VmRequestZone.StatInitial ?
VmRequestZone.StatInitial * 512 / 1024 :
VmRequestZone.InitialPages * 512 / 1024,
VmRequestZone.TuneSample,
VmRequestZone.TunePeriod,
&VmRequestZone.StatPages,
&VmRequestZone.StatCount,
VmRequestZone.ExtendPages,
VmRequestZone.ExtendPages * 512 / 1024,
VmHttp2Zone.InitialPages, VmHttp2Zone.InitialPages * 512 / 1024,
VmHttp2Zone.ExtendPages, VmHttp2Zone.ExtendPages * 512 / 1024,
JpiWsSize, JpiWsSize * 512 / 1048576,
JpiWsPeak, JpiWsPeak * 512 / 1048576,
JpiVirtPeak, JpiVirtPeak * 512 / 1048576,
JpiPagFilCnt, HttpdProcess.PgFlQuo,
((ulong)JpiPagFilCnt * 512) / 1048576,
((ulong)HttpdProcess.PgFlQuo * 512) / 1048576,
100 - PercentOf32((ulong)JpiPagFilCnt,(ulong)HttpdProcess.PgFlQuo));
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
#if VM_DECC
VmReportZone (rqptr, &VmDeccZone);
VmReportZone (rqptr, &VmGeneralZone);
VmReportZone (rqptr, &VmCacheZone);
VmReportZone (rqptr, &VmPermCacheZone);
#endif /* VM_DECC */
#if VM_OPENSSL
if (VmOpenSslZone.ZoneId != (ulong)-1) VmReportZone (rqptr, &VmOpenSslZone);
#endif
#if VM_EXPAT
if (VmExpatZone.ZoneId != (ulong)-1) VmReportZone (rqptr, &VmExpatZone);
#endif
if (VMSnok (status = lib$show_vm (&ShowVmCode123, &VmWrite, rqptr)))
FaoToNet (rqptr, "lib$show_vm() !&S\n", status);
if (VMSnok (status = lib$show_vm (&ShowVmCode567, &VmWrite, rqptr)))
FaoToNet (rqptr, "lib$show_vm() !&S\n", status);
FaoToNet (rqptr, "\n");
Context = 0;
while ((status = lib$find_vm_zone (&Context, &ZoneId)) == SS$_NORMAL)
{
status = lib$show_vm_zone (&ZoneId, &ShowVmZoneDetail, &VmWrite, rqptr);
if (VMSnok (status)) FaoToNet (rqptr, "lib$show_vm_zone() !&S\n", status);
}
if (status != LIB$_NOTFOU)
FaoToNet (rqptr, "lib$find_vm_zone() !&S\n", status);
/**********/
#if SHOW_VM_64
/**********/
if (VMSnok (status = lib$show_vm_64 (&ShowVm64Code123, &VmWrite,
(int64)rqptr)))
FaoToNet (rqptr, "lib$show_vm_64() !&S\n", status);
if (VMSnok (status = lib$show_vm_64 (&ShowVm64Code567, &VmWrite,
(int64)rqptr)))
FaoToNet (rqptr, "lib$show_vm_64() !&S\n", status);
FaoToNet (rqptr, "\n");
Context64 = 0;
while ((status = lib$find_vm_zone_64 (&Context64, &ZoneId64)) == SS$_NORMAL)
{
status = lib$show_vm_zone_64 (&ZoneId64, &ShowVm64ZoneDetail, &VmWrite64,
(int64)rqptr);
if (VMSnok (status))
FaoToNet (rqptr, "lib$show_vm_zone_64() !&S\n", status);
}
if (status != LIB$_NOTFOU)
FaoToNet (rqptr, "lib$find_vm_zone_64() !&S\n", status);
#endif /* SHOW_VM_64 */
FaolToNet (rqptr, EndPageFao, NULL);
rqptr->rqResponse.PreExpired = PRE_EXPIRE_ADMIN;
ResponseHeader200 (rqptr, "text/html", &rqptr->NetWriteBufferDsc);
#if !VM_BACKPORT_FOR_DTAG
AdminEnd (rqptr);
#endif
}
/*****************************************************************************/
/*
See VmReportZone().
*/
void VmDebugOpenSslZone (char *module, int lnumber)
{
/*********/
/* begin */
/*********/
fprintf (stdout, "***** %s:%d *****\n", module, lnumber);
VmReportZone (NULL, &VmOpenSslZone);
}
/*****************************************************************************/
/*
If |rqptr| is NULL this is written to <stdout> allowing it to be used for
inline code debugging. Suggest something like the immediately above.
*/
void VmReportZone
(
REQUEST_STRUCT *rqptr,
VM_ZONE *ZonePtr
)
{
static char HeapFao [] =
"!AZ Heap Initial Pages: !UL (!ULkB)\n\
!#AZ Extend Pages: !UL (!ULkB)\n";
static char StatsFao [] =
"!AZ Statistics (<span style=\"font-size:90%\">LIB$VM..</span>)\n";
static char DataFao [] =
" calloc() !&,UL\n\
malloc() !&,UL\n\
realloc() !&,UL\n\
free() !&,UL\n\
Allocated !&,@SQ bytes\n\
Deallocated !&,@SQ bytes\n\
Still In Use !&,@SQ bytes (!AZ!AZ∆ !AZ!&,@SQ !SL%)\n\
Max !&,@SQ bytes\n";
static char PlusMinus [2] = { 0, 0 };
int blen, status, percentage;
ushort slen;
int64 Delta64;
char *bptr;
char LastLookAgo [64],
ReportBuffer [1024];
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM, "VmReportZone()");
if (!ZonePtr->ZoneId) return;
ThisLongAgo (&ZonePtr->LastLookTime64, LastLookAgo);
if (!ZonePtr->LastLookBytes)
Delta64 = 0;
else
Delta64 = ZonePtr->InUseBytes - ZonePtr->LastLookBytes;
if (Delta64 > 0)
PlusMinus[0] = '+';
else
PlusMinus[0] = '\0';
if (Delta64)
percentage = (int)((Delta64 * 100) / ZonePtr->InUseBytes);
else
percentage = 0;
bptr = ReportBuffer;
blen = sizeof(ReportBuffer)-1;
/* if zone-based memory management disabled */
if (ZonePtr->ZoneId == (ulong)-1)
status = FaoToBuffer (bptr, blen, &slen, StatsFao,
ZonePtr->ReportTitle);
else
status = FaoToBuffer (bptr, blen, &slen, HeapFao,
ZonePtr->ReportTitle,
ZonePtr->InitialPages,
ZonePtr->InitialPages * 512 / 1024,
strlen(ZonePtr->ReportTitle), " ",
ZonePtr->ExtendPages,
ZonePtr->ExtendPages * 512 / 1024);
bptr += slen;
blen -= slen;
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
if (rqptr && slen)
{
*bptr++ = '\n';
blen--;
}
status = FaoToBuffer (bptr, blen, &slen, DataFao,
ZonePtr->CallocCount,
ZonePtr->MallocCount,
ZonePtr->ReallocCount,
ZonePtr->FreeCount,
&ZonePtr->AllocBytes,
&ZonePtr->DeallocBytes,
&ZonePtr->InUseBytes,
LastLookAgo, LastLookAgo[0] ? " " : "",
PlusMinus, &Delta64, percentage,
&ZonePtr->InUseMaxBytes);
bptr += slen;
blen -= slen;
if (VMSnok (status)) ErrorNoticed (rqptr, status, NULL, FI_LI);
if (rqptr && slen)
{
*bptr++ = '\n';
blen--;
}
*bptr = '\0';
if (rqptr)
FaoToNet (rqptr, "!AZ", ReportBuffer);
else
fwrite (ReportBuffer, bptr-ReportBuffer, 1, stdout);
ZonePtr->LastLookBytes = ZonePtr->InUseBytes;
sys$gettim (&ZonePtr->LastLookTime64);
}
/*****************************************************************************/
/*
Action routine for lib$show_vm*() routines. Simply write the contents of the
parameter descriptor to the client plus a newline character - using some
specially crafted HTML forbidden character escapes allowing an anchor to shine
through.
*/
int VmWrite
(
struct dsc$descriptor *DscPtr,
REQUEST_STRUCT *rqptr
)
{
static int EmptyLineCount;
int status;
char buf [1024];
char *cptr, *czptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM, "VmWrite()");
#if 0
FaoToNet (rqptr, "!UL |!-!#AZ|\n", DscPtr->dsc$w_length,
DscPtr->dsc$a_pointer);
#endif
czptr = (cptr = DscPtr->dsc$a_pointer) + DscPtr->dsc$w_length;
/* Zone Id = 7B65E290, Zone name = "DEFAULT_ZONE" */
if (cptr < czptr && MATCH8 (cptr, "Zone Id "))
{
if (!VmReportPlus)
{
for (sptr = cptr + 20; sptr < czptr; sptr++)
{
if (MATCH8 (sptr, "Zone nam"))
{
sptr += 13;
if (!MATCH4 (sptr, "WASD"))
{
VmReportThisOne = false;
return (SS$_NORMAL);
}
break;
}
}
}
VmReportThisOne = true;
EmptyLineCount = 0;
FaoToNet (rqptr, "!90*-\n\n");
zptr = (sptr = buf) + sizeof(buf)-8;
while (cptr < czptr && sptr < zptr)
{
if (*cptr == '<')
{
if (SAME3 (cptr, '<a '))
*sptr++ = *cptr++;
else
if (SAME4 (cptr, '</a>'))
{
SET4 (sptr, '</a>');
sptr += 4;
cptr += 4;
}
else
{
SET4 (sptr, '<');
sptr += 4;
cptr++;
}
}
else
if (SAME2 (cptr, '\">'))
{
SET2 (sptr, '\">');
sptr += 2;
cptr += 2;
}
else
if (*cptr == '>')
{
SET4 (sptr, '>');
sptr += 4;
cptr++;
}
else
if (*cptr == '&')
{
SET4 (sptr, '&');
sptr += 4;
*sptr++ = ';';
cptr++;
}
else
*sptr++ = *cptr++;
}
}
else
if (VmReportThisOne)
{
if (cptr < czptr)
EmptyLineCount = 0;
else
if (EmptyLineCount++)
return (SS$_NORMAL);
zptr = (sptr = buf) + sizeof(buf)-8;
while (cptr < czptr && sptr < zptr)
*sptr++ = *cptr++;
}
else
return (SS$_NORMAL);
*sptr++ = '\n';
*sptr = '\0';
NetWriteBuffered (rqptr, NULL, buf, sptr-buf);
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
Wrapper for VmWrite().
*/
#if SHOW_VM_64
int VmWrite64
(
struct dsc$descriptor *DscPtr,
int64 UserParam /* 32 bit pointer to the request */
)
{
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM, "VmWrite64()");
VmWrite (DscPtr, (ulong)UserParam);
return (SS$_NORMAL);
}
#endif /* SHOW_VM_64 */
/*****************************************************************************/
/*
*/
void VmDebug (ulong ZoneId)
{
#ifdef DBUG
static ulong ShowVmZoneDetail = 3;
int status;
ulong Context;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchThis (WATCHALL, WATCH_MOD_VM, "VmDebug() !UL !60*-", ZoneId);
if (ZoneId)
{
status = lib$show_vm_zone (&ZoneId, &ShowVmZoneDetail, 0, 0);
if (VMSnok (status)) exit (status);
}
else
{
Context = 0;
while ((status = lib$find_vm_zone (&Context, &ZoneId)) == SS$_NORMAL)
{
status = lib$show_vm_zone (&ZoneId, &ShowVmZoneDetail, 0, 0);
if (VMSnok (status)) exit (status);
}
}
if (WATCH_MODULE(WATCH_MOD_VM) || WATCHON_WATCHOFF)
WatchDataFormatted ("----------\n");
#endif
}
/*****************************************************************************/