Changeset 304


Ignore:
Timestamp:
Sep 10, 2017, 6:07:46 AM (3 years ago)
Author:
Valery V. Sedletski
Message:
  • Delete unneeded tracepoints from FS_MOUNT.
  • Make ulDataLen equal to ulValidDataLen on exFAT (instead of being equal to rounded up to a cluster size value).
Location:
trunk/src
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/ifs/fat32.tsf

    r296 r304  
    11851185   DESC="GetMemAccess",
    11861186   FMT="Waiting for a heap access",
    1187 
    1188 TRACE MINOR=0x4071
    1189    TP=@STATIC,
    1190    TYPE=(MID),
    1191    GROUP=OTHER,
    1192    DESC="FS_MOUNT 1",
    1193    FMT="tracepoint 1",
    1194 
    1195 TRACE MINOR=0x4072
    1196    TP=@STATIC,
    1197    TYPE=(MID),
    1198    GROUP=OTHER,
    1199    DESC="FS_MOUNT 2",
    1200    FMT="tracepoint 2",
    1201 
    1202 TRACE MINOR=0x4073
    1203    TP=@STATIC,
    1204    TYPE=(MID),
    1205    GROUP=OTHER,
    1206    DESC="FS_MOUNT 3",
    1207    FMT="tracepoint 3",
    1208 
    1209 TRACE MINOR=0x4074
    1210    TP=@STATIC,
    1211    TYPE=(MID),
    1212    GROUP=OTHER,
    1213    DESC="FS_MOUNT 4",
    1214    FMT="tracepoint 4",
    1215 
    1216 TRACE MINOR=0x4075
    1217    TP=@STATIC,
    1218    TYPE=(MID),
    1219    GROUP=OTHER,
    1220    DESC="FS_MOUNT 5",
    1221    FMT="tracepoint 5",
    1222 
    1223 TRACE MINOR=0x4076
    1224    TP=@STATIC,
    1225    TYPE=(MID),
    1226    GROUP=OTHER,
    1227    DESC="FS_MOUNT 6",
    1228    FMT="tracepoint 6",
    1229 
    1230 TRACE MINOR=0x4077
    1231    TP=@STATIC,
    1232    TYPE=(MID),
    1233    GROUP=OTHER,
    1234    DESC="FS_MOUNT 7",
    1235    FMT="tracepoint 7",
    1236 
    1237 TRACE MINOR=0x4078
    1238    TP=@STATIC,
    1239    TYPE=(MID),
    1240    GROUP=OTHER,
    1241    DESC="FS_MOUNT 8",
    1242    FMT="tracepoint 8",
    1243 
    1244 TRACE MINOR=0x4079
    1245    TP=@STATIC,
    1246    TYPE=(MID),
    1247    GROUP=OTHER,
    1248    DESC="FS_MOUNT 9",
    1249    FMT="tracepoint 9",
    1250 
    1251 TRACE MINOR=0x407a
    1252    TP=@STATIC,
    1253    TYPE=(MID),
    1254    GROUP=OTHER,
    1255    DESC="FS_MOUNT a",
    1256    FMT="tracepoint a",
    1257 
    1258 TRACE MINOR=0x407b
    1259    TP=@STATIC,
    1260    TYPE=(MID),
    1261    GROUP=OTHER,
    1262    DESC="FS_MOUNT b",
    1263    FMT="tracepoint b",
    1264 
    1265 TRACE MINOR=0x407c
    1266    TP=@STATIC,
    1267    TYPE=(MID),
    1268    GROUP=OTHER,
    1269    DESC="FS_MOUNT c",
    1270    FMT="tracepoint c",
    1271 
    1272 TRACE MINOR=0x407d
    1273    TP=@STATIC,
    1274    TYPE=(MID),
    1275    GROUP=OTHER,
    1276    DESC="FS_MOUNT d",
    1277    FMT="tracepoint d",
    1278 
    1279 TRACE MINOR=0x407e
    1280    TP=@STATIC,
    1281    TYPE=(MID),
    1282    GROUP=OTHER,
    1283    DESC="FS_MOUNT e",
    1284    FMT="tracepoint e",
    1285 
    1286 TRACE MINOR=0x407f
    1287    TP=@STATIC,
    1288    TYPE=(MID),
    1289    GROUP=OTHER,
    1290    DESC="FS_MOUNT f",
    1291    FMT="tracepoint f",
    1292 
    1293 TRACE MINOR=0x4080
    1294    TP=@STATIC,
    1295    TYPE=(MID),
    1296    GROUP=OTHER,
    1297    DESC="FS_MOUNT 10",
    1298    FMT="tracepoint 10",
    1299 
    1300 TRACE MINOR=0x4081
    1301    TP=@STATIC,
    1302    TYPE=(MID),
    1303    GROUP=OTHER,
    1304    DESC="FS_MOUNT 11",
    1305    FMT="tracepoint 11",
    1306 
    1307 TRACE MINOR=0x4082
    1308    TP=@STATIC,
    1309    TYPE=(MID),
    1310    GROUP=OTHER,
    1311    DESC="FS_MOUNT 12",
    1312    FMT="tracepoint 12",
    1313 
    1314 TRACE MINOR=0x4083
    1315    TP=@STATIC,
    1316    TYPE=(MID),
    1317    GROUP=OTHER,
    1318    DESC="FS_MOUNT 13",
    1319    FMT="tracepoint 13",
    1320 
    1321 TRACE MINOR=0x4084
    1322    TP=@STATIC,
    1323    TYPE=(MID),
    1324    GROUP=OTHER,
    1325    DESC="FS_MOUNT 14",
    1326    FMT="tracepoint 14",
    1327 
    1328 TRACE MINOR=0x4085
    1329    TP=@STATIC,
    1330    TYPE=(MID),
    1331    GROUP=OTHER,
    1332    DESC="FS_MOUNT 15",
    1333    FMT="tracepoint 15",
    1334 
    1335 TRACE MINOR=0x4086
    1336    TP=@STATIC,
    1337    TYPE=(MID),
    1338    GROUP=OTHER,
    1339    DESC="FS_MOUNT 16",
    1340    FMT="tracepoint 16",
    1341 
    1342 TRACE MINOR=0x4087
    1343    TP=@STATIC,
    1344    TYPE=(MID),
    1345    GROUP=OTHER,
    1346    DESC="FS_MOUNT 17",
    1347    FMT="tracepoint 17",
    1348 
    1349 TRACE MINOR=0x4088
    1350    TP=@STATIC,
    1351    TYPE=(MID),
    1352    GROUP=OTHER,
    1353    DESC="FS_MOUNT 18",
    1354    FMT="tracepoint 18",
    1355 
    1356 TRACE MINOR=0x4089
    1357    TP=@STATIC,
    1358    TYPE=(MID),
    1359    GROUP=OTHER,
    1360    DESC="FS_MOUNT 19",
    1361    FMT="tracepoint 19",
    1362 
    1363 TRACE MINOR=0x408a
    1364    TP=@STATIC,
    1365    TYPE=(MID),
    1366    GROUP=OTHER,
    1367    DESC="FS_MOUNT 1a",
    1368    FMT="tracepoint 1a",
    1369 
    1370 TRACE MINOR=0x408b
    1371    TP=@STATIC,
    1372    TYPE=(MID),
    1373    GROUP=OTHER,
    1374    DESC="FS_MOUNT 1b",
    1375    FMT="tracepoint 1b",
    1376 
    1377 TRACE MINOR=0x408c
    1378    TP=@STATIC,
    1379    TYPE=(MID),
    1380    GROUP=OTHER,
    1381    DESC="FS_MOUNT 1c",
    1382    FMT="tracepoint 1c",
    1383 
    1384 TRACE MINOR=0x408d
    1385    TP=@STATIC,
    1386    TYPE=(MID),
    1387    GROUP=OTHER,
    1388    DESC="FS_MOUNT 1d",
    1389    FMT="tracepoint 1d",
    1390 
    1391 TRACE MINOR=0x408e
    1392    TP=@STATIC,
    1393    TYPE=(MID),
    1394    GROUP=OTHER,
    1395    DESC="FS_MOUNT 1e",
    1396    FMT="tracepoint 1e",
    1397 
    1398 TRACE MINOR=0x408f
    1399    TP=@STATIC,
    1400    TYPE=(MID),
    1401    GROUP=OTHER,
    1402    DESC="FS_MOUNT 1f",
    1403    FMT="tracepoint 1f",
    1404 
    1405 TRACE MINOR=0x4090
    1406    TP=@STATIC,
    1407    TYPE=(MID),
    1408    GROUP=OTHER,
    1409    DESC="FS_MOUNT 20",
    1410    FMT="tracepoint 20",
    1411 
    1412 TRACE MINOR=0x4091
    1413    TP=@STATIC,
    1414    TYPE=(MID),
    1415    GROUP=OTHER,
    1416    DESC="FS_MOUNT 21",
    1417    FMT="tracepoint 21",
    1418 
    1419 TRACE MINOR=0x4092
    1420    TP=@STATIC,
    1421    TYPE=(MID),
    1422    GROUP=OTHER,
    1423    DESC="FS_MOUNT 22",
    1424    FMT="tracepoint 22",
    1425 
    1426 TRACE MINOR=0x4093
    1427    TP=@STATIC,
    1428    TYPE=(MID),
    1429    GROUP=OTHER,
    1430    DESC="FS_MOUNT 23",
    1431    FMT="tracepoint 23",
    1432 
    1433 TRACE MINOR=0x4094
    1434    TP=@STATIC,
    1435    TYPE=(MID),
    1436    GROUP=OTHER,
    1437    DESC="FS_MOUNT 24",
    1438    FMT="tracepoint 24",
    1439 
    1440 TRACE MINOR=0x4095
    1441    TP=@STATIC,
    1442    TYPE=(MID),
    1443    GROUP=OTHER,
    1444    DESC="FS_MOUNT 25",
    1445    FMT="tracepoint 25",
    1446 
    1447 TRACE MINOR=0x4096
    1448    TP=@STATIC,
    1449    TYPE=(MID),
    1450    GROUP=OTHER,
    1451    DESC="FS_MOUNT 26",
    1452    FMT="tracepoint 26",
    1453 
    1454 TRACE MINOR=0x4097
    1455    TP=@STATIC,
    1456    TYPE=(MID),
    1457    GROUP=OTHER,
    1458    DESC="FS_MOUNT 27",
    1459    FMT="tracepoint 27",
    1460 
    1461 TRACE MINOR=0x4098
    1462    TP=@STATIC,
    1463    TYPE=(MID),
    1464    GROUP=OTHER,
    1465    DESC="FS_MOUNT 28",
    1466    FMT="tracepoint 28",
    1467 
    1468 TRACE MINOR=0x4099
    1469    TP=@STATIC,
    1470    TYPE=(MID),
    1471    GROUP=OTHER,
    1472    DESC="FS_MOUNT 29",
    1473    FMT="tracepoint 29",
    1474 
    1475 TRACE MINOR=0x409a
    1476    TP=@STATIC,
    1477    TYPE=(MID),
    1478    GROUP=OTHER,
    1479    DESC="FS_MOUNT 2a",
    1480    FMT="tracepoint 2a",
    1481 
    1482 TRACE MINOR=0x409b
    1483    TP=@STATIC,
    1484    TYPE=(MID),
    1485    GROUP=OTHER,
    1486    DESC="FS_MOUNT 2b",
    1487    FMT="tracepoint 2b",
    1488 
    1489 TRACE MINOR=0x409c
    1490    TP=@STATIC,
    1491    TYPE=(MID),
    1492    GROUP=OTHER,
    1493    DESC="FS_MOUNT 2c",
    1494    FMT="tracepoint 2c",
    1495 
    1496 TRACE MINOR=0x409d
    1497    TP=@STATIC,
    1498    TYPE=(MID),
    1499    GROUP=OTHER,
    1500    DESC="FS_MOUNT 2d",
    1501    FMT="tracepoint 2d",
    1502 
    1503 TRACE MINOR=0x409e
    1504    TP=@STATIC,
    1505    TYPE=(MID),
    1506    GROUP=OTHER,
    1507    DESC="FS_MOUNT 2e",
    1508    FMT="tracepoint 2e",
    1509 
    1510 TRACE MINOR=0x409f
    1511    TP=@STATIC,
    1512    TYPE=(MID),
    1513    GROUP=OTHER,
    1514    DESC="FS_MOUNT 2f",
    1515    FMT="tracepoint 2f",
  • trunk/src/ifs/fat32a.c

    r303 r304  
    31923192#ifdef INCL_LONGLONG
    31933193      pDirStreamNew->u.Stream.ullValidDataLen = pFileSize->ullFileSize;
    3194       pDirStreamNew->u.Stream.ullDataLen =
    3195          (pFileSize->ullFileSize / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
    3196          ((pFileSize->ullFileSize % pVolInfo->ulClusterSize) ? pVolInfo->ulClusterSize : 0);
     3194      pDirStreamNew->u.Stream.ullDataLen = pDirStreamNew->u.Stream.ullValidDataLen;
     3195      //   (pFileSize->ullFileSize / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
     3196      //   ((pFileSize->ullFileSize % pVolInfo->ulClusterSize) ? pVolInfo->ulClusterSize : 0);
    31973197#else
    31983198      Assign(pDirStreamNew->u.Stream.ullValidDataLen, pFileSize->ullFileSize);
    3199       Assign(pDirStreamNew->u.Stream.ullDataLen,
    3200          (pFileSize->ullFileSize / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
    3201          ((pFileSize->ullFileSize % pVolInfo->ulClusterSize) ? pVolInfo->ulClusterSize : 0));
     3199      Assign(pDirStreamNew->u.Stream.ullDataLen, pDirStreamNew->u.Stream.ullValidDataLen);
     3200      //   (pFileSize->ullFileSize / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
     3201      //   ((pFileSize->ullFileSize % pVolInfo->ulClusterSize) ? pVolInfo->ulClusterSize : 0));
    32023202#endif
    32033203      }
  • trunk/src/ifs/ifsea.c

    r303 r304  
    10361036#ifdef INCL_LONGLONG
    10371037         pDirStreamNew->u.Stream.ullValidDataLen = (ULONGLONG)pFEAL->cbList;
    1038          pDirStreamNew->u.Stream.ullDataLen =
    1039             (pFEAL->cbList / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
    1040             (pFEAL->cbList % pVolInfo->ulClusterSize ? pVolInfo->ulClusterSize : 0);
     1038         pDirStreamNew->u.Stream.ullDataLen = pDirStreamNew->u.Stream.ullValidDataLen;
     1039         //   (pFEAL->cbList / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
     1040         //   (pFEAL->cbList % pVolInfo->ulClusterSize ? pVolInfo->ulClusterSize : 0);
    10411041#else
    10421042         AssignUL(pDirStreamNew->u.Stream.ullValidDataLen, pFEAL->cbList);
    1043          AssignUL(pDirStreamNew->u.Stream.ullDataLen,
    1044             (pFEAL->cbList / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
    1045             (pFEAL->cbList % pVolInfo->ulClusterSize ? pVolInfo->ulClusterSize : 0));
     1043         AssignUL(pDirStreamNew->u.Stream.ullDataLen, pDirStreamNew->u.Stream.ullValidDataLen);
     1044         //   (pFEAL->cbList / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
     1045         //   (pFEAL->cbList % pVolInfo->ulClusterSize ? pVolInfo->ulClusterSize : 0));
    10461046#endif
    10471047         }
     
    11081108#ifdef INCL_LONGLONG
    11091109         pDirStreamNew->u.Stream.ullValidDataLen = (ULONGLONG)pFEAL->cbList;
    1110          pDirStreamNew->u.Stream.ullDataLen =
    1111             (pFEAL->cbList / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
    1112             (pFEAL->cbList % pVolInfo->ulClusterSize ? pVolInfo->ulClusterSize : 0);
     1110         pDirStreamNew->u.Stream.ullDataLen = pDirStreamNew->u.Stream.ullValidDataLen;
     1111         //   (pFEAL->cbList / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
     1112         //   (pFEAL->cbList % pVolInfo->ulClusterSize ? pVolInfo->ulClusterSize : 0);
    11131113#else
    11141114         AssignUL(pDirStreamNew->u.Stream.ullValidDataLen, pFEAL->cbList);
    1115          AssignUL(pDirStreamNew->u.Stream.ullDataLen,
    1116             (pFEAL->cbList / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
    1117             (pFEAL->cbList % pVolInfo->ulClusterSize ? pVolInfo->ulClusterSize : 0));
     1115         AssignUL(pDirStreamNew->u.Stream.ullDataLen, pDirStreamNew->u.Stream.ullValidDataLen);
     1116         //   (pFEAL->cbList / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
     1117         //   (pFEAL->cbList % pVolInfo->ulClusterSize ? pVolInfo->ulClusterSize : 0));
    11181118#endif
    11191119         }
  • trunk/src/ifs/ifsfile.c

    r303 r304  
    431431#ifdef INCL_LONGLONG
    432432                  pDirEntryStream->u.Stream.ullValidDataLen = size;
    433                   pDirEntryStream->u.Stream.ullDataLen =
    434                      (size / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
    435                      (size % pVolInfo->ulClusterSize ? pVolInfo->ulClusterSize : 0);
     433                  pDirEntryStream->u.Stream.ullDataLen = size;
     434                  //   (size / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
     435                  //   (size % pVolInfo->ulClusterSize ? pVolInfo->ulClusterSize : 0);
    436436#else
    437437                  {
     
    439439
    440440                  Assign(pDirEntryStream->u.Stream.ullValidDataLen, size);
    441                   pDirEntryStream->u.Stream.ullDataLen = DivUL(size, pVolInfo->ulClusterSize);
    442                   pDirEntryStream->u.Stream.ullDataLen = MulUL(pDirEntryStream->u.Stream.ullDataLen, pVolInfo->ulClusterSize);
    443                   ullRest = ModUL(size, pVolInfo->ulClusterSize);
    444 
    445                   if (NeqUL(ullRest, 0))
    446                      AssignUL(&ullRest, pVolInfo->ulClusterSize);
    447                   else
    448                      AssignUL(&ullRest, 0);
    449 
    450                   pDirEntryStream->u.Stream.ullDataLen = Add(DirEntryStream.u.Stream.ullDataLen, ullRest);
     441                  Assign(pDirEntryStream->u.Stream.ullDataLen, size);
     442                  //pDirEntryStream->u.Stream.ullDataLen = DivUL(size, pVolInfo->ulClusterSize);
     443                  //pDirEntryStream->u.Stream.ullDataLen = MulUL(pDirEntryStream->u.Stream.ullDataLen, pVolInfo->ulClusterSize);
     444                  //ullRest = ModUL(size, pVolInfo->ulClusterSize);
     445
     446                  //if (NeqUL(ullRest, 0))
     447                  //   AssignUL(&ullRest, pVolInfo->ulClusterSize);
     448                  //else
     449                  //   AssignUL(&ullRest, 0);
     450
     451                  //pDirEntryStream->u.Stream.ullDataLen = Add(DirEntryStream.u.Stream.ullDataLen, ullRest);
    451452                  }
    452453#endif
     
    722723#ifdef INCL_LONGLONG
    723724                  pDirEntryStream->u.Stream.ullValidDataLen = size;
    724                   pDirEntryStream->u.Stream.ullDataLen =
    725                      (size / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
    726                      (size % pVolInfo->ulClusterSize ? pVolInfo->ulClusterSize : 0);
     725                  pDirEntryStream->u.Stream.ullDataLen = size;
     726                  //   (size / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
     727                  //   (size % pVolInfo->ulClusterSize ? pVolInfo->ulClusterSize : 0);
    727728#else
    728729                  {
     
    731732
    732733                  Assign(pDirEntryStream->u.Stream.ullValidDataLen, size);
    733                   pDirEntryStream->u.Stream.ullDataLen = DivUL(size, pVolInfo->ulClusterSize);
    734                   pDirEntryStream->u.Stream.ullDataLen = MulUL(pDirEntryStream->u.Stream.ullDataLen, pVolInfo->ulClusterSize);
    735                   ullRest = ModUL(size, pVolInfo->ulClusterSize);
    736 
    737                   if (NeqUL(ullRest, 0))
    738                      AssignUL(&ullRest, pVolInfo->ulClusterSize);
    739                   else
    740                      AssignUL(&ullRest, 0);
    741 
    742                   pDirEntryStream->u.Stream.ullDataLen = Add(pDirEntryStream->u.Stream.ullDataLen, ullRest);
     734                  Assign(pDirEntryStream->u.Stream.ullDataLen, size);
     735                  //pDirEntryStream->u.Stream.ullDataLen = DivUL(size, pVolInfo->ulClusterSize);
     736                  //pDirEntryStream->u.Stream.ullDataLen = MulUL(pDirEntryStream->u.Stream.ullDataLen, pVolInfo->ulClusterSize);
     737                  //ullRest = ModUL(size, pVolInfo->ulClusterSize);
     738
     739                  //if (NeqUL(ullRest, 0))
     740                  //   AssignUL(&ullRest, pVolInfo->ulClusterSize);
     741                  //else
     742                  //   AssignUL(&ullRest, 0);
     743
     744                  //pDirEntryStream->u.Stream.ullDataLen = Add(pDirEntryStream->u.Stream.ullDataLen, ullRest);
    743745                  }
    744746#endif
     
    30683070#ifdef INCL_LONGLONG
    30693071            pDirEntryStream->u.Stream.ullValidDataLen = size;
    3070             pDirEntryStream->u.Stream.ullDataLen =
    3071                (size / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
    3072                (size % pVolInfo->ulClusterSize ? pVolInfo->ulClusterSize : 0);
     3072            pDirEntryStream->u.Stream.ullDataLen = size;
     3073            //   (size / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
     3074            //   (size % pVolInfo->ulClusterSize ? pVolInfo->ulClusterSize : 0);
    30733075#else
    30743076            {
     
    30763078
    30773079            Assign(pDirEntryStream->u.Stream.ullValidDataLen, size);
    3078             pDirEntryStream->u.Stream.ullDataLen = DivUL(size, pVolInfo->ulClusterSize);
    3079             pDirEntryStream->u.Stream.ullDataLen = MulUL(pDirEntryStream->u.Stream.ullDataLen, pVolInfo->ulClusterSize);
    3080             ullRest = ModUL(size, pVolInfo->ulClusterSize);
    3081 
    3082             if (NeqUL(ullRest, 0))
    3083                AssignUL(&ullRest, pVolInfo->ulClusterSize);
    3084             else
    3085                AssignUL(&ullRest, 0);
    3086 
    3087             pDirEntryStream->u.Stream.ullDataLen = Add(pDirEntryStream->u.Stream.ullDataLen, ullRest);
     3080            Assign(pDirEntryStream->u.Stream.ullDataLen, size);
     3081            //pDirEntryStream->u.Stream.ullDataLen = DivUL(size, pVolInfo->ulClusterSize);
     3082            //pDirEntryStream->u.Stream.ullDataLen = MulUL(pDirEntryStream->u.Stream.ullDataLen, pVolInfo->ulClusterSize);
     3083            //ullRest = ModUL(size, pVolInfo->ulClusterSize);
     3084
     3085            //if (NeqUL(ullRest, 0))
     3086            //   AssignUL(&ullRest, pVolInfo->ulClusterSize);
     3087            //else
     3088            //   AssignUL(&ullRest, 0);
     3089
     3090            //pDirEntryStream->u.Stream.ullDataLen = Add(pDirEntryStream->u.Stream.ullDataLen, ullRest);
    30883091            }
    30893092#endif
  • trunk/src/ifs/ifsfind.c

    r303 r304  
    15261526#ifdef INCL_LONGLONG
    15271527                  pfFind->cbFile = pDir->u.Stream.ullValidDataLen;
    1528                   pfFind->cbFileAlloc = pDir->u.Stream.ullDataLen;
     1528                  pfFind->cbFileAlloc =
     1529                     (pDir->u.Stream.ullValidDataLen / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
     1530                     ((pDir->u.Stream.ullValidDataLen % pVolInfo->ulClusterSize) ? pVolInfo->ulClusterSize : 0);
    15291531#else
    15301532                  pfFind->cbFile = pDir->u.Stream.ullValidDataLen.ulLo;
    1531                   pfFind->cbFileAlloc = pDir->u.Stream.ullDataLen.ulLo;
     1533                  pfFind->cbFileAlloc =
     1534                     (pDir->u.Stream.ullValidDataLen.ulLo / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
     1535                     ((pDir->u.Stream.ullValidDataLen.ulLo % pVolInfo->ulClusterSize) ? pVolInfo->ulClusterSize : 0);
    15321536#endif
    15331537                  }
     
    15371541#ifdef INCL_LONGLONG
    15381542                  pfFind->cbFile = pDir->u.Stream.ullValidDataLen;
    1539                   pfFind->cbFileAlloc = pDir->u.Stream.ullDataLen;
     1543                  pfFind->cbFileAlloc = pDir->u.Stream.ullValidDataLen;
    15401544#else
    15411545                  iAssign(&pfFind->cbFile, *(PLONGLONG)&pDir->u.Stream.ullValidDataLen);
    1542                   iAssign(&pfFind->cbFileAlloc, *(PLONGLONG)&pDir->u.Stream.ullDataLen);
     1546                  iAssign(&pfFind->cbFileAlloc, *(PLONGLONG)&pDir->u.Stream.ullValidDataLen);
    15431547#endif
    15441548                  }
     
    15481552#ifdef INCL_LONGLONG
    15491553                  pfFind->cbFile = pDir->u.Stream.ullValidDataLen;
    1550                   pfFind->cbFileAlloc = pDir->u.Stream.ullDataLen;
     1554                  pfFind->cbFileAlloc = pDir->u.Stream.ullValidDataLen;
    15511555#else
    15521556                  pfFind->cbFile = pDir->u.Stream.ullValidDataLen.ulLo;
    1553                   pfFind->cbFileAlloc = pDir->u.Stream.ullDataLen.ulLo;
     1557                  pfFind->cbFileAlloc =
     1558                     (pDir->u.Stream.ullValidDataLen.ulLo / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
     1559                     ((pDir->u.Stream.ullValidDataLen.ulLo % pVolInfo->ulClusterSize) ? pVolInfo->ulClusterSize : 0);
    15541560#endif
    15551561                  }
     
    15591565#ifdef INCL_LONGLONG
    15601566                  pfFind->cbFile = pDir->u.Stream.ullValidDataLen;
    1561                   pfFind->cbFileAlloc = pDir->u.Stream.ullDataLen;
     1567                  pfFind->cbFileAlloc = pDir->u.Stream.ullValidDataLen;
    15621568#else
    15631569                  iAssign(&pfFind->cbFile, *(PLONGLONG)&pDir->u.Stream.ullValidDataLen);
    1564                   iAssign(&pfFind->cbFileAlloc, *(PLONGLONG)&pDir->u.Stream.ullDataLen);
     1570                  iAssign(&pfFind->cbFileAlloc, *(PLONGLONG)&pDir->u.Stream.ullValidDataLen);
    15651571#endif
    15661572                  }
     
    15701576#ifdef INCL_LONGLONG
    15711577                  pfFind->cbFile = pDir->u.Stream.ullValidDataLen;
    1572                   pfFind->cbFileAlloc = pDir->u.Stream.ullDataLen;
     1578                  pfFind->cbFileAlloc = pDir->u.Stream.ullValidDataLen;
    15731579#else
    15741580                  pfFind->cbFile = pDir->u.Stream.ullValidDataLen.ulLo;
    1575                   pfFind->cbFileAlloc = pDir->u.Stream.ullDataLen.ulLo;
     1581                  pfFind->cbFileAlloc =
     1582                     (pDir->u.Stream.ullValidDataLen.ulLo / pVolInfo->ulClusterSize) * pVolInfo->ulClusterSize +
     1583                     ((pDir->u.Stream.ullValidDataLen.ulLo % pVolInfo->ulClusterSize) ? pVolInfo->ulClusterSize : 0);
    15761584#endif
    15771585                  }
     
    15811589#ifdef INCL_LONGLONG
    15821590                  pfFind->cbFile = pDir->u.Stream.ullValidDataLen;
    1583                   pfFind->cbFileAlloc = pDir->u.Stream.ullDataLen;
     1591                  pfFind->cbFileAlloc = pDir->u.Stream.ullValidDataLen;
    15841592#else
    15851593                  iAssign(&pfFind->cbFile, *(PLONGLONG)&pDir->u.Stream.ullValidDataLen);
    1586                   iAssign(&pfFind->cbFileAlloc, *(PLONGLONG)&pDir->u.Stream.ullDataLen);
     1594                  iAssign(&pfFind->cbFileAlloc, *(PLONGLONG)&pDir->u.Stream.ullValidDataLen);
    15871595#endif
    15881596                  }
  • trunk/src/ifs/ifsmount.c

    r302 r304  
    119119            }
    120120
    121          Trace("tracepoint 1%m", 0x4071);
    122121         if (!hDupVBP)   /* initial mounting of the volume */
    123122            {
     
    138137            pVolInfo->bFatType = GetFatType(pSect);
    139138
    140             Trace("tracepoint 2%m", 0x4072);
    141139            if (pVolInfo->bFatType == FAT_TYPE_NONE)
    142140               {
     
    146144               }
    147145
    148             Trace("tracepoint 3%m", 0x4073);
    149146            if ( (pVolInfo->bFatType < FAT_TYPE_FAT32) &&
    150147                 ((! f32Parms.fFat) || ! (fat_mask & (1UL << pvpfsi->vpi_drive))) )
     
    155152               }
    156153
    157             Trace("tracepoint 4%m", 0x4074);
    158154            if ( (pVolInfo->bFatType == FAT_TYPE_FAT32) &&
    159155                 ! (fat32_mask & (1UL << pvpfsi->vpi_drive)) )
     
    165161
    166162#ifdef EXFAT
    167             Trace("tracepoint 5%m", 0x4075);
    168163            if ( (pVolInfo->bFatType == FAT_TYPE_EXFAT) &&
    169164                 ((! f32Parms.fExFat) || ! (exfat_mask & (1UL << pvpfsi->vpi_drive))) )
     
    175170#endif
    176171
    177             Trace("tracepoint 6%m", 0x4076);
    178172            switch (pVolInfo->bFatType)
    179173               {
     
    208202               }
    209203
    210             Trace("tracepoint 7%m", 0x4077);
    211204            rc = FSH_FORCENOSWAP(SELECTOROF(pVolInfo));
    212205            if (rc)
     
    216209               goto FS_MOUNT_EXIT;
    217210               }
    218             Trace("tracepoint 8%m", 0x4078);
    219211            *((PVOLINFO *)pvpfsd->vpd_work) = pVolInfo;
    220212            *((ULONG *)pvpfsd->vpd_work + 1) = FAT32_VPB_MAGIC;
     
    222214            pVolInfo->pNextVolInfo = NULL;
    223215
    224             Trace("tracepoint 9%m", 0x4079);
    225216            if (!pGlobVolInfo)
    226217               {
     
    238229
    239230               // check for 0xf6 symbol (is the BPB erased?)
    240                Trace("tracepoint a%m", 0x407a);
    241231               for (i = 0; i < sizeof(BOOTSECT0); i++)
    242232                  {
     
    245235                  }
    246236
    247                Trace("tracepoint b%m", 0x407b);
    248237               if (i == sizeof(BOOTSECT0))
    249238                  {
     
    259248                  }
    260249
    261                Trace("tracepoint c%m", 0x407c);
    262250               if (i == sizeof(BOOTSECT0))
    263251                  {
     
    285273                  }
    286274
    287                Trace("tracepoint d%m", 0x407d);
    288275               if (! fValidBoot)
    289276                  {
     
    293280                  }
    294281
    295                Trace("tracepoint e%m", 0x407e);
    296282               if (! fNewBoot)
    297283                  {
     
    300286                  }
    301287
    302                Trace("tracepoint f%m", 0x407f);
    303288               if (pVolInfo->bFatType < FAT_TYPE_FAT32)
    304289                  {
     
    441426                     }
    442427
    443                      Trace("tracepoint 10%m", 0x4080);
    444428                     if (fValidBoot)
    445429                        {
     
    452436               else if (pVolInfo->bFatType == FAT_TYPE_FAT32)
    453437                  {
    454                      Trace("tracepoint 11%m", 0x4081);
    455438                     if (fValidBoot)
    456439                        {
     
    464447               else if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
    465448                  {
    466                      Trace("tracepoint 12%m", 0x4082);
    467449                     if (fValidBoot)
    468450                        {
     
    482464            for the n-th remount it's a reinitialization of the old VPB
    483465         */
    484          Trace("tracepoint 13%m", 0x4083);
    485466         memcpy(&pVolInfo->BootSect, pSect, sizeof (BOOTSECT));
    486467
     
    494475#endif
    495476
    496          Trace("tracepoint 14%m", 0x4084);
    497477#ifdef EXFAT
    498478         if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
     
    517497            }
    518498
    519          Trace("tracepoint 15%m", 0x4085);
    520499         pVolInfo->pBootFSInfo = (PBOOTFSINFO)(pVolInfo + 1);
    521500         pVolInfo->pbFatSector = (PBYTE)(pVolInfo->pBootFSInfo + 1);
     
    523502         pVolInfo->pbFatBits = (PBYTE)pVolInfo->pbFatSector + SECTOR_SIZE * 8 * 3;
    524503         
    525          Trace("tracepoint 16%m", 0x4086);
    526504#ifdef EXFAT
    527505         if (pVolInfo->bFatType < FAT_TYPE_EXFAT)
     
    556534
    557535         // size of a subcluster block
    558          Trace("tracepoint 17%m", 0x4087);
    559536         pVolInfo->ulBlockSize = min(pVolInfo->ulClusterSize, 32768UL);
    560537
     
    568545         pVolInfo->fFormatInProgress = FALSE;
    569546
    570          Trace("tracepoint 18%m", 0x4088);
    571547         if (usDefaultRASectors == 0xFFFF)
    572548            pVolInfo->usRASectors = (USHORT)(pVolInfo->ulBlockSize / pVolInfo->BootSect.bpb.BytesPerSector ) * 2;
     
    582558#endif
    583559
    584          Trace("tracepoint 19=%m", 0x4089);
    585560         if (pVolInfo->bFatType == FAT_TYPE_FAT32 && pSect->bpb.FSinfoSec != 0xFFFF)
    586561            {
     
    591566            memset(pVolInfo->pBootFSInfo, 0, sizeof (BOOTFSINFO));
    592567
    593          Trace("tracepoint 1a%m", 0x408a);
    594568         if (pVolInfo->bFatType < FAT_TYPE_FAT32)
    595569            {
     
    613587            pVolInfo->BootSect.bpb.FSinfoSec = 0xFFFF;
    614588            }
    615          Trace("tracepoint 1b%m", 0x408b);
    616589         if (pVolInfo->bFatType == FAT_TYPE_FAT32)
    617590            {
     
    632605               }
    633606
    634          Trace("tracepoint 1c%m", 0x408c);
    635607#ifdef INCL_LONGLONG
    636608            pVolInfo->BootSect.bpb.BigTotalSectors = (ULONG)((PBOOTSECT1)pSect)->ullVolumeLength; ////
     
    647619         pVolInfo->BootSect.ulVolSerial = pvpfsi->vpi_vid;
    648620
    649          Trace("tracepoint 1d%m", 0x408d);
    650621         if (! pVolInfo->BootSect.bpb.BigSectorsPerFat)
    651622            // if partition is small
    652623            pVolInfo->BootSect.bpb.BigSectorsPerFat = pVolInfo->BootSect.bpb.SectorsPerFat;
    653624
    654          Trace("tracepoint 1e%m", 0x408e);
    655625         pVolInfo->ulTotalClusters =
    656626            (pVolInfo->BootSect.bpb.BigTotalSectors - pVolInfo->ulStartOfData) / pVolInfo->SectorsPerCluster;
    657627
    658          Trace("tracepoint 1f%m", 0x408f);
    659628         if (pVolInfo->bFatType == FAT_TYPE_FAT32)
    660629            {
    661             if (pSect->bpb.ExtFlags & 0x0080)
    662630               {
    663631               pVolInfo->ulActiveFatStart +=
     
    674642            if (((PBOOTSECT1)pSect)->usVolumeFlags & VOL_FLAG_ACTIVEFAT)
    675643               {
    676                pVolInfo->ulActiveFatStart += ((PBOOTSECT1)pSect)->ulFatLength; ////
     644               pVolInfo->ulActiveFatStart += ((PBOOTSECT1)pSect)->ulFatLength;
    677645               }
    678646
     
    695663#endif
    696664
    697          Trace("tracepoint 20%m", 0x4090);
    698665         if (fValidBoot)
    699666            {
     
    701668            USHORT usSize = 11;
    702669
    703             Trace("tracepoint 21%m", 0x4091);
    704670            memset(pszVolLabel, 0, sizeof(pszVolLabel));
    705671            memset(pvpfsi->vpi_text, 0, sizeof(pvpfsi->vpi_text));
    706672
    707             Trace("tracepoint 22%m", 0x4092);
    708673            fGetSetVolLabel(pVolInfo, INFO_RETRIEVE, pszVolLabel, &usSize);
    709674            // prevent writing the FSInfo sector in pVolInfo->pbFatSector buffer
     
    712677            pVolInfo->ulCurFatSector = 0xffff;
    713678
    714             Trace("tracepoint 23%m", 0x4093);
    715679            if (! pszVolLabel || ! *pszVolLabel)
    716680               strcpy(pvpfsi->vpi_text, "UNLABELED  ");
     
    718682               strcpy(pvpfsi->vpi_text, pszVolLabel);
    719683           
    720             Trace("tracepoint 24%m", 0x4094);
    721684            memset(pVolInfo->BootSect.VolumeLabel, 0, sizeof(pVolInfo->BootSect.VolumeLabel));
    722685            memcpy(pVolInfo->BootSect.VolumeLabel, pvpfsi->vpi_text, sizeof(pVolInfo->BootSect.VolumeLabel));
    723686            }
    724687
    725          Trace("tracepoint 25%m", 0x4095);
    726688         rc = CheckWriteProtect(pVolInfo);
    727689         if (rc && rc != ERROR_WRITE_PROTECT)
     
    730692            goto FS_MOUNT_EXIT;
    731693            }
    732          Trace("tracepoint 26%m", 0x4096);
    733694         if (rc == ERROR_WRITE_PROTECT)
    734695            pVolInfo->fWriteProtected = TRUE;
    735696
    736          Trace("tracepoint 27%m", 0x4097);
    737697         if (f32Parms.fCalcFree ||
    738698            pVolInfo->pBootFSInfo->ulFreeClusters == 0xFFFFFFFF ||
     
    743703            }
    744704
    745          Trace("tracepoint 28%m", 0x4098);
    746705         pDevCaps  = pvpfsi->vpi_pDCS;
    747706         pVolChars = pvpfsi->vpi_pVCS;
     
    753712         //   }
    754713
    755          Trace("tracepoint 29%m", 0x4099);
    756714         if ( pVolChars && (pVolChars->VolDescriptor & VC_REMOVABLE_MEDIA) )
    757715            pVolInfo->fRemovable = TRUE;
    758716
    759          Trace("tracepoint 2a%m", 0x409a);
    760717         if (! pVolInfo->fRemovable)
    761718            pVolInfo->fDiskCleanOnMount = pVolInfo->fDiskClean = GetDiskStatus(pVolInfo);
     
    764721            pVolInfo->fDiskCleanOnMount = pVolInfo->fDiskClean = TRUE;
    765722
    766          Trace("tracepoint 2b%m", 0x409b);
    767723         if (!pVolInfo->fDiskCleanOnMount && f32Parms.fMessageActive & LOG_FS)
    768724            Message("DISK IS DIRTY!");
    769725
    770          Trace("tracepoint 2c%m", 0x409c);
    771726         if (pVolInfo->fWriteProtected)
    772727            pVolInfo->fDiskCleanOnMount = TRUE;
    773728
    774          Trace("tracepoint 2d%m", 0x409d);
    775729         if (pDevCaps && f32Parms.fMessageActive & LOG_FS)
    776730            {
     
    791745            }
    792746
    793          Trace("tracepoint 2e%m", 0x409e);
    794747         if (pDevCaps && pDevCaps->Strategy2)
    795748            {
     
    804757            }
    805758
    806          Trace("tracepoint 2f%m", 0x409f);
    807759         rc = 0;
    808760         break;
  • trunk/src/ufat32/fatfunc.c

    r303 r304  
    32093209      {
    32103210      DirStreamNew.u.Stream.ullValidDataLen = pFileSize->ullFileSize;
    3211       DirStreamNew.u.Stream.ullDataLen =
    3212          (pFileSize->ullFileSize / pCD->ulClusterSize) * pCD->ulClusterSize +
    3213          ((pFileSize->ullFileSize % pCD->ulClusterSize) ? pCD->ulClusterSize : 0);
     3211      DirStreamNew.u.Stream.ullDataLen = pFileSize->ullFileSize;
     3212      //   (pFileSize->ullFileSize / pCD->ulClusterSize) * pCD->ulClusterSize +
     3213      //   ((pFileSize->ullFileSize % pCD->ulClusterSize) ? pCD->ulClusterSize : 0);
    32143214      }
    32153215#endif
     
    40684068               pNewEntryStream->u.Stream.ulFirstClus = ulCluster;
    40694069               pNewEntryStream->u.Stream.ullValidDataLen = cbBuf;
    4070                pNewEntryStream->u.Stream.ullDataLen =
    4071                   (cbBuf / pCD->ulClusterSize) * pCD->ulClusterSize +
    4072                   ((cbBuf % pCD->ulClusterSize) ? pCD->ulClusterSize : 0);
     4070               pNewEntryStream->u.Stream.ullDataLen = cbBuf;
     4071               //   (cbBuf / pCD->ulClusterSize) * pCD->ulClusterSize +
     4072               //   ((cbBuf % pCD->ulClusterSize) ? pCD->ulClusterSize : 0);
    40734073               }
    40744074#endif
Note: See TracChangeset for help on using the changeset viewer.