> Attention!

New threads need to be created only inroot partition! In the future, they will be processed by moderators.

If you posted a new version of the program, please notify the moderator by clicking the "Complaint" button on your message.

Catalog of Android programs


58 pagesV  1 2 3 4 5 6 > »  
 
REPLY
> WwR MTK | The program works with ROM files.
vvaaavv
Message#1
02.04.17, 21:03
Old resident
*******
[offline]

Group: Friendssavagemessiahzine.com
Messages 742
Check in: 17.02.12

Reputation:-  401  +

WwR MTK download


Version: 2.40 Beta

Last update of the program in the header:01.04.2018

!!!ATTENTION!!!
The program can be consideredservice which assumes the presence of certain knowledge in this area.

The level of complexity of the topic: difficult

Short description:
The program works with ROM files (read from the device usingSP Flash Tool ), based on MTK processors.
  • Pulls Preloader.bin from the ROM dump file.
  • You can cut a certain segment of the read memory.
  • Cut the ROM file into parts, based on the Scatter file.
  • Finds the PMT sections, PGPT (SGPT), on the basis of information from these sections creates a Scatter file.
  • Calculates from the Recovery_log the name of the partitions, their starts and lengths.
  • Works on ADB. Creates backup copies of partitions (If you have root rights).
  • Creating a scatter file for devices with root rights on the MTK platform. Backup firmware any devices.
  • Cuts out unnecessary sectors (Spare) from read memory dump from phones with NAND memory.
  • New features will be added.
PC requirements: Windows XP or higher
Device Requirements: device on the MTK platform and ROM from the SP Flash Tool
Program interface: Русский / English
Developer: [email protected]

Download:
Version: 2.40 Beta:
Attached fileWwR_2.40_Rus.rar(32.69 MB)
Attached fileWwR_2.40_Eng.rar(32.69 MB)
Download another file and put it in the folder with the program. It contains information about installed applications in the device, the file is not mine, butotido2010
The file itself in the subject of the message:WwR MTK (Post otido2010 # 71925327)
Modified Template.ini file with support for new platforms, here in this post: WwR MTK (Post vvaaavv # 80174563)
Screenshots:
Attached Image
Attached Image

Attached Image
Attached Image

Attached Image
Attached Image

Attached Image
List of changes
  • Version 1.8
    • Improved speed performance: ROM cuts, Spare cuts, Partition Search.
    • In the Search section search for regions on the ball, search PMT, PGPT, MBR + EBR1.
    • Ability to make a scatter file from the PMT and PGPT sections.
    • Made a log program.

  • Version 2.0
    • Added the ability to make a scatter file based on the information: dumchar_info or partinfo.
    • Also added the ability to compare files and scatter files by start and length values.
    • Minor bugs fixed.
    • Resized to fit on laptops.
    • Size of the program: 910х640.

  • Version 2.15
    • Minor bugs fixed. (Wrongly found the last FF at the ends. The fix for MT6589 is the old-fashioned scatter file)

  • Version 2.20
    • Implemented automatically pull the Preloader from the ROM file, if it is there when it is executed:<Cut the ROM into a folder ..>.

  • Version 2.30
    • Changed the program interface, added support for English.
    • Implemented autopilot. Fixed bugs and errors.
    • Many changes introduced !!!

  • Version 2.40
    • Changed the program interface. Switch tabs by the old, or from the menu, or by buttons.
    • Implemented ADB mode. (Device information, List of sections, List of installed applications (view, install, delete), View Build.prop, ...)
    • In ADB mode with root rights, the creation of backup on all platforms (Dumchar_info, Partinfo, Partitions, Full_ROM) is implemented
    • Fixed bug in pulling Preloader, on some models.
    • The table of the Scatter file is improved, you can see all the fields in the Scatter file. Support for new lines is included.
    • In autopilot, the creation of a Scatter file from the Recovery_Log information has been improved. The program actually checks the starting values ​​of the LK, Boot, System, UserData, Cache sections and if they match, it makes a Scatter file. If it does not match, it calculates the offset. Then it rechecks again, and if the value of starts coincides, it uses them to create a Scatter file.
    • Fixed bug if more than 50 sections are used when creating a Scatter file.
    • Added. All sections that are not in the template file are marked as non-firmware. If the original, stock Scatter file is selected, the program automatically adds these values ​​to the template file.
    • Fixed autodetection of read sections in ROM file.
    • Redesigned partition search algorithm. The found Ext_4 sections have the specified image length, so there is no point in looking for other sections in them.
    • A new platform definition algorithm is involved, not by LK (uboot), but by Recovery_Log. If Recovery_Log is not in the ROM file, then the LK detection algorithm is used.
    • In autopilot when creating a scatter file, the program recognizes in fact which file system is on partitions, i.e. EXT4_IMG, UBI_IMG, NORMAL_ROM.
    • Many changes introduced !!!

Instructions
We make a full backup of the memory of the phone or tablet based on MTK processors.

It is necessary to read all available memory from the device, the so-called ROM files:
ROM_0 is usually a memory block containing the Preloader (EMMC_BOOT_1),
and ROM_1 is a memory block containing everything else (EMMC_USER), there are many ways to do this. For example through the programSP Flash Tool.
Approximate structure of device memory
Attached Image

If you do not know anything about the device:
Using the SP Flash Tool, without a scatter file
With the help of the SP Flash Tool, without a scatter file.
  • The instruction is suitable for all types of phones.
  • Including, when on hands it turns out it is unclear what kind (meaning all the various fakes under known brands)

Imagine:
We have a phone on hand. It is not clear what. The name is not known, the phone does not turn on. (Only connects to the computer in firmware mode). Accordingly, the user does not know how to subtract data from the phone. In order to subtract data from the phone, you must haveScatter file and Preloader . How can I get them? can you try ...
So, for this you will need to download the program:SP Flash Tool and Wwr_mtk and of course install Drivers (VCOM) for phone.
It is advisable before starting any actions, to go to Recovery on the device itself, there is nothing special to do there, just when you go into it, if Recovery is a stock, it creates a Log file in the memory cache of the device, which can be useful.
    The procedure is as follows:
  • 1. Find out what type of processor is used in the phone.
  • 2. In the SP Flash Tool, subtract at least the first megabyte of data from the phone.
  • 3. In WwR_MTK pull out the native Preloader.
  • 4. In the SP Flash Tool run RAM Test. (It will show how much memory is used in the phone)
  • 5. In the SP Flash Tool, read the entire memory dump (Make a full backup of the firmware from the phone).

    Now in more detail:
  • 1. Find out what type of processor is used in the phone.
  • 2. In the SP Flash Tool, subtract at least the first megabyte of data from the phone:
    2.1. You can randomly try to find out: in WwR_MTK there is a tab:<Blank scatter file>go to it, no matter what processor, choose any, also with memory.
    Further<Create and save as ..>, choose where and under what name to save.
    2.2. Next, in the SP Flash Tool, select the created empty scatter in the tab<Download>in field<Scatter-loading>, then go to the tab<ReadBack>Push the button<Add>. A new line will appear below. We click on it twice and select the storage location of the so-called ROM_0 block.
    Push<Save>, then a selection of values ​​appears, according to which the SP Flash Tool should read the memory from the device (phone or tablet).
    Next, select:
    Type - HEX
    Region: - EMMC_BOOT_1, (If there is such a choice), or EMMC_USER.
    Start Address: - choose 0x0000000000000000, that is, the very beginning.
    Lenght: - choose 0x0000000000100000, i.e. length.
    In details
    Usually on new platforms (MT67xx and MT6580) the Preloader is in EMMC_BOOT_1, and all other data is in EMMC_USER.
    We need a region with Preloader. It is usually located at the very beginning of the phone’s memory and does not exceed the size in megabytes (I have not seen the Preloader more than 200 Kb).
    1 Megabyte: 1048576 bytes in decimal form
    1 Megabyte: 0x100000 in hexadecimal form
    (0x parameter - indicates that the number is presented in hexadecimal)
    You can specify and:
    512 KB: 0x80000
    256 KB: 0x40000.
    You can specify more than it is, nothing terrible will happen.
    Therefore, in the SP Flash Tool, select the values:
    Where<Start Address:>- choose<0x00000000000000>, ie the very beginning
    and length:<Lenght:> - <0x0000000000100000>
    Next, click<Ok>and<Read back>. And we completely connect the phone to the computer. (Figure 200, 201).
    Figure 200, if the memory in the EMMC device:
    Attached Image
    Figure 201, if the memory in the NAND device:
    Attached Image
    2.3. If an error occurs (Figure 202), then we change in WwR_MTK the type of processor shown by the SP Flash Tool. Repeat the action from paragraph 2.1.
    Figure 202:
    Attached Image
    2.4. If an error occurs (Figure 203), then we change the type of memory shown by the SP Flash Tool in WwR_MTK. Repeat the action from paragraph 2.1.
    Figure 203:
    Attached Image
    2.5. If successful, a window with a green circle and a check mark should come out (Figure 204).
    Figure 204:
    Attached Image

  • 3. In WwR_MTK, pull out the native Preloader:
    3.1. If the ROM file was considered normal, continue: In WwR_MTK, select our file at the very top of the program. Go to the tab<Preloader>, push the button<Preloader Analysis>. We look information:
    The name of the Preloader, the type of processor, the type of memory, and the ability to pull it out of the ROM file (Figure 205).
    Figure 205:
    Attached Image

    *** Note:
    ** On the new platforms (MT67xx and MT6580), this type of processor (MT6752) is always indicated in the Preloader, you should not pay attention to it,
    ** On MT65xx platforms, shows the correct processor type.

    3.2. Push the button<Pull out Preloader and save as ..>, indicate the location of the save. -Now you have your own Preloader, which definitely does not hurt anything.

  • 4. In the SP Flash Tool run RAM Test. (It will show how much memory is used in the phone):
    4.1. Go to the SP Flash Tool tab<Download>click the mouse in the empty field below<Location>in the table where the name of the file with Preloader should be.
    And choose our native Preloader, which we just pulled out (Figure 206)
    Figure 206:
    Attached Image
    4.2. Very carefully we read this item, and the more we do !!!
    Next, go to the tab<Memory Test>, remove all the checkboxes there except<Ram test> (Figure 207-1)
    Figure 207-1:
    Attached Image
    Click on the start. And we connect the phone completely off to the computer.
    Must pass the memory test, which is in the phone. We look at the line:
    EMMC_PART_USER Size = 0x ................
    - there is the total amount of memory specified in the HEX. (Figure 207-2).
    Figure 207-2:
    Attached Image

    If you have a platform MT6757 / MT6797 and instead<Ram test>coming out<DRAM Flip Test>(Figure 207-3).
    Figure 207-3:
    Attached Image
    Then you can go on the alternate path: Read the first megabyte EMMC_USER, and specify it in WwR_MTK in the tab<Autopilot>, the program will analyze the file and provide accurate information about the size of the total memory in the device (Figure 207-4 and 207-5).
    Figure 207-4, 207-5:
    Attached Image
    Attached Image
    This example uses markup.<GPT>, It goes at the very beginning of EMMC_USER,and in the PGPT section there is information about the full amount of memory. There is no such information in the MBR markup !!!

  • 5. In the SP Flash Tool, read the entire memory dump (Make a full backup of the firmware from the phone):
    5.1. Now you need to read the full backup from the phone.
    5.2. Go to the tab<ReadBack>Push the button<Add>. Another line will appear in the table below, just click on it and indicate the location of the file to be saved. Then there is a choice of values ​​by which the SP Flash Tool should read the memory from the device. Choose:
    Type - HEX,
    Region: - EMMC_USER
    Start Address: - choose 0x0000000000000000, that is, the very beginning,
    Lenght: - choose length 0x ................, which we considered in<Ram test>
    (For example: 0x00000001d2000000, it is possible and so: 0x1d2000000, Zero in front is for beauty and clarity, the same as 05 will be 5)
    5.3. Next, click<Ok>and<Read back>. And we completely connect the phone to the computer. (Figure 208).
    Figure 208:
    Attached Image
    5.4. The process of reading the full dump of the phone will go. The process is not fast. If successful, a window with a green circle and a check mark should come out (Figure 204).
    Figure 204:
    Attached Image
If everything went well, then you have a full ROM of the entire device memory.

If we have an idea about the device, there is a scatter file from the stock (official) firmware, in which you are sure that this is from your device:
Using the SP Flash Tool, the scatter file is available from the stock firmware
Using the SP Flash Tool, the scatter file is already available.
To do this, you will need to download the program:SP Flash Tool and Wwr_mtk and of course install Drivers (VCOM) for phone.
It is advisable before starting any actions, to go to Recovery on the device itself, there is nothing special to do there, just when you go into it, if Recovery is a stock, it creates a Log file in the memory cache of the device, which can be useful.
    The procedure is as follows:
  • 1. Prepare a scatter file for full reading in the SP Flash Tool.
  • 2. In the SP Flash Tool read ROM file containing Preloader.
  • 3. In WwR_MTK pull out the native Preloader.
  • 4. In the SP Flash Tool run RAM Test. (It will show how much memory is used in the phone)
  • 5. In the SP Flash Tool, read the entire memory dump (Make a full backup of the firmware from the phone).

    Now in more detail:
  • 1. Prepare a scatter file for full reading in the SP Flash Tool:
    It is necessary to open the scatter file with a text editor, preferablyNotePad ++ and delete all lines after the first section with Preloader. Save the edited file with a different name to prevent overwriting the stock scatter file (Figure 223)
    Figure 223:
    Attached Image

  • 2. In the SP Flash Tool, subtract at least the first megabyte of data from the phone:
    2.1. Next, in the SP Flash Tool, select the edited empty scatter in the tab<Download>in field<Scatter-loading>, then go to the tab<ReadBack>Push the button<Add>. A new line will appear below. We click on it twice and select the storage location of the so-called ROM_0 block.
    Push<Save>, then a selection of values ​​appears on which the SP Flash Tool should read the memory from the device (phone or tablet).
    Next, select:
    Type - HEX
    Region: - EMMC_BOOT_1, (If there is such a choice), or EMMC_USER.
    Start Address: - choose 0x0000000000000000, that is, the very beginning.
    Lenght: - choose 0x0000000000100000, i.e. length.
    In details
    Usually on new platforms (MT67xx and MT6580) the Preloader is in EMMC_BOOT_1, and all other data is in EMMC_USER.
    We need a region with Preloader. It is usually located at the very beginning of the phone’s memory and does not exceed the size in megabytes (I have not seen the Preloader more than 200 Kb).
    1 Megabyte: 1048576 bytes in decimal form
    1 Megabyte: 0x100000 in hexadecimal form
    (0x parameter - indicates that the number is presented in hexadecimal)
    You can specify and:
    512 KB: 0x80000
    256 KB: 0x40000.
    You can specify more than it is, nothing terrible will happen.
    Therefore, in the SP Flash Tool, select the values:
    Where<Start Address:>- choose<0x00000000000000>, ie the very beginning
    and length:<Lenght:> - <0x0000000000100000>
    Next, click<Ok>and<Read back>. And we completely connect the phone to the computer. (Figure 200, 201).
    Figure 200, if the memory in the EMMC device:
    Attached Image
    Figure 201, if the memory in the NAND device:
    Attached Image
    2.2. If an error occurs (Figure 202), then you are not using the scatter file from your device. It is best to use the instruction without the scatter file, which is located above.
    Figure 202:
    Attached Image
    2.3. If an error occurs (Figure 203), it means that you are not using the scatter file from your device. It is best to use the instruction without the scatter file, which is located above.
    Figure 203:
    Attached Image
    2.4. If successful, a window with a green circle and a check mark should come out (Figure 204).
    Figure 204:
    Attached Image

  • 3. In WwR_MTK, pull out the native Preloader:
    3.1. If the ROM file was considered normal, continue: In WwR_MTK, select our file at the very top of the program. Go to the tab<Preloader>, push the button<Preloader Analysis>. We look information:
    The name of the Preloader, the type of processor, the type of memory, and the ability to pull it out of the ROM file (Figure 205).
    Figure 205:
    Attached Image

    *** Note:
    ** On the new platforms (MT67xx and MT6580), this type of processor (MT6752) is always indicated in the Preloader, you should not pay attention to it,
    ** On MT65xx platforms, shows the correct processor type.

    3.2. Push the button<Pull out Preloader and save as ..>, indicate the location of the save. -Now you have your own Preloader, which definitely does not hurt anything.

  • 4. In the SP Flash Tool run RAM Test. (It will show how much memory is used in the phone):
    4.1. Go to the SP Flash Tool tab<Download>click the mouse in the empty field below<Location>in the table where the name of the file with Preloader should be.
    And choose our native Preloader, which we just pulled out (Figure 206)
    Figure 206:
    Attached Image
    4.2. Very carefully we read this item, and the more we do !!!
    Next, go to the tab<Memory Test>, remove all the checkboxes there except<Ram test> (Figure 207-1)
    Figure 207-1:
    Attached Image
    Click on the start. And we connect the phone completely off to the computer.
    Must pass the memory test, which is in the phone. We look at the line:
    EMMC_PART_USER Size = 0x ................
    - there is the total amount of memory specified in the HEX. (Figure 207-2).
    Figure 207-2:
    Attached Image

    If you have a platform MT6757 / MT6797 and instead<Ram test>coming out<DRAM Flip Test>(Figure 207-3).
    Figure 207-3:
    Attached Image
    Then you can go on the alternate path: Read the first megabyte EMMC_USER, and specify it in WwR_MTK in the tab<Autopilot>, the program will analyze the file and provide accurate information about the size of the total memory in the device (Figure 207-4 and 207-5).
    Figure 207-4, 207-5:
    Attached Image
    Attached Image
    This example uses markup.<GPT>, It goes at the very beginning of EMMC_USER,and in the PGPT section there is information about the full amount of memory. There is no such information in the MBR markup !!!

  • 5. In the SP Flash Tool, read the entire memory dump (Make a full backup of the firmware from the phone):
    5.1. Now you need to read the full backup from the phone.
    5.2. Go to the tab<ReadBack>Push the button<Add>. Another line will appear in the table below, just click on it and indicate the location of the file to be saved. Then there is a choice of values ​​by which the SP Flash Tool should read the memory from the device. Choose:
    Type - HEX,
    Region: - EMMC_USER
    Start Address: - choose 0x0000000000000000, that is, the very beginning,
    Lenght: - choose length 0x ................, which we considered in<Ram test>
    (For example: 0x00000001d2000000, it is possible and so: 0x1d2000000, Zero in front is for beauty and clarity, the same as 05 will be 5)
    5.3. Next, click<Ok>and<Read back>. And we completely connect the phone to the computer. (Figure 208).
    Figure 208:
    Attached Image
    5.4. The process of reading the full dump of the phone will go. The process is not fast. If successful, a window with a green circle and a check mark should come out (Figure 204).
    Figure 204:
    Attached Image
If everything went well, then you have a full ROM of the entire device memory.

Now you need to pull the firmware from the existing ROM files (s) and create a scatter file:
Creating a scatter file and extracting partitions from a ROM file using WwR_MTK
Autopilot program
    Required:

  • In the WwR_MTK program in the tab<Autopilot>click on the button<Select a file..>(in blue) and select the merged ROM (EMMC_USER). See picture 213.
    Figure 213:
    Attached Image
  • The program itself will search for the necessary information, and if it finds the PMT or PGPT tables, it will perform all the actions itself.
  • If the program asks for a file, the merged memory region EMMC_BOOT_1, then it is needed, you must also choose (Figure 214)
    Figure 214:
    Attached Image
  • We are waiting for the completion of all processes. And delve into the written "Conclusion" of the program. Next, go to the tab<Scatter file>(Figure 215)
    Figure 215:
    Attached Image
  • Next, remove the checkboxes from the sections that you do not need (usually Cache, UserData (The UserData section contains your personal information - Photos, Videos, etc.)), and go back to the tab<Autopilot>(Figure 216).
    Figure 216:
    Attached Image
  • There we choose in paragraph<4) Collect firmware:>If you need to assemble the firmware: Cut the ROM into sections, create a Scatter file, you must click on the appropriate button. If you only need a Scatter file, respectively, a button:<Create Scatter file ..>(Figure 217). And wait for the completion of all processes.
    Figure 217:
    Attached Image

    The program WwR_MTK in autopilot mode performs the following actions:

    If it finds PGPT:
  • Analyzes the presence of a preloader, and calls the ROM file selection dialog (ROM_0 region of read EMMC_BOOT_1) containing the preloader.
  • Performs a preloader analysis. The name of the preloader. Memory. The ability to pull it out of ROM_0.
  • From the PGPT section, it pulls out information about the existing sections in ROM_1, the name of the sections, the starting position and the length.
  • It performs the conversion of the received information about the sections, determines which sections are stitched and which are not (According to the template).
  • Renders sections in the future scatter file. (By pattern).
  • Adds sections that are not in PGPT (Preloader, PGPT, SGPT).
  • Calculates the total memory size from the information in the PGPT section.
  • Calculates sections RESERVED (Sections that are not sewn in any case, but should be in the scatter file). Corrects start positions and lengths for them (FFFF0084 - for example).
  • Specifies the location of the LK partition.
  • Finds the type of processor in the LK section.
  • Determines how much the ROM_1 file is read, prepares the ROM_1 file for partitioning, removes checkboxes from future partitions that are not read.
    Assembles firmware:
  • Creates a scatter file.
  • Splits ROM_1 file into sections.
  • Pulls out the preloader.

    If PMT finds:
  • Analyzes the presence of a preloader, and calls the ROM file selection dialog (ROM_0 region of read EMMC_BOOT_1) containing the preloader.
  • Performs a preloader analysis. The name of the preloader. Memory. The ability to pull it out of ROM_0.
  • From the section, the PMT pulls information about the existing sections in ROM_1, the name of the sections, the starting position and the length.
  • It performs the conversion of the received information about the sections, determines which sections are stitched and which are not (According to the template).
  • Renders sections in the future scatter file. (By pattern).
  • Adds sections that are not in the PMT (Preloader). If necessary.
  • Approximately calculates the total memory size based on the length of all sections in the firmware.
  • Specifies the location of the LK partition.
  • Finds the type of processor in the LK section.
  • Determines how much the ROM_1 file is read, prepares the ROM_1 file for partitioning, removes checkboxes from future partitions that are not read.
    Assembles firmware:
  • Creates a scatter file.
  • Splits ROM_1 file into sections.
  • Pulls out the preloader.

    If it finds Recovery_Log and the necessary information about the firmware sections:
  • It determines the necessary information about the sections of the firmware, pulls out the names of sections, their positions of length and start.
  • Performs analysis for matching the found sections and their starts in the ROM file; if there is an offset, then it calculates this offset.
  • Analyzes the presence of a preloader, and calls the ROM file selection dialog (ROM_0 region of read EMMC_BOOT_1) containing the preloader.
  • Performs a preloader analysis. The name of the preloader. Memory. The ability to pull it out of ROM_0.
  • It performs the conversion of the received information about the sections, determines which sections are stitched and which are not (According to the template).
  • Renders sections in the future scatter file. (By pattern).
  • Adds sections that do not exist (for example, Preloader, if necessary).
  • Approximately calculates the total memory size based on the length of all sections in the firmware.
  • Specifies the location of the LK partition.
  • Finds the type of processor in the LK section.
  • Finds the type of processor in Recovery_Log, if such information is there.
  • Determines how much the ROM_1 file is read, prepares the ROM_1 file for partitioning, removes checkboxes from future partitions that are not read.
    Assembles firmware:
  • Creates a scatter file.
  • Splits ROM_1 file into sections.
  • Pulls out the preloader.

    If Spare finds:
  • Automatically fixes it (You just need to specify the folder to save the corrected ROM). Immediately selects the corrected ROM file and starts the scan again.
    What is Spare:
    • AT<SP Flash Tool>in the tab<Memory Test>shows that the total memory of the device is 512MB (0x20000000 in HEX). And after reading it, the file for some reason becomes more by 16MB - this is Spare, which is not needed. It must be removed. This is done in the tab:<Spare Cut>.
    • In order to<SP Flash Tool>read without it<Spare>, you need to specify in the read parameters:<Read Page Only>.
    • So in the program WwR_MTK open tab<Spare Cut>, select at the top the file read together with<Spare>Press the button<Cut and save as ..>and wait for the completion of the process (Figure 220)
      Figure 220:
      Attached Image

    • This is an example<ROM>file read with<Spare>opened in the HEX editor (Figure 221)
      Figure 221:
      Attached Image

      *** Note: The program WwR_MTK (version 2.30 and higher) for any scan determines whether this Spare is in the read firmware or not. If there is, offers to get rid of it. This read option appears when memory is used.<NAND>.
      ATTENTION: You also need to know the size of the read block, it is determined by the Scatter file (I know that there are 0x20000 and 0x40000) the size of the blocks of the UBIFS file system depends on this parameter (My tests on the difference of blocks of this parameter lead to different read ROMs, i.e. when comparing they are DIFFERENT, although read from the same device, and nothing has changed, even the device did not turn on)
Semi-automatic way
    Required:
  • In WwR_MTK, perform a ROM dump scan to find partitions (PMT, PGPT, SGPT).
    If PMT, PGPT, SGPT sections are found:
  • Create a scatter file.
  • Splitting a ROM file into sections.
  • Use as directed. (Mounting partitions, extracting the data you need, and so on)

    Now more:

  • Search sections:
    Open the program WwR_MTK, select our full backup (ROM_1 file) go to the tab<Search for sections>, there we press a button<Start scan>and wait until the program finds PGPT or PMT partitions,
    You can then stop the search with the button<Stop>or wait for the end of the process. Then double-click on the blue label:<There is!!! Found partition table ...>and the partition table will open in a clear way.
    After that, the button is activated.<Copy Values ​​to - Scatter File>, click on it. The program itself will find the section LK (UBOOT) and subtracts reliable information about the type of processor.
    And go to the tab<Scatter file>. (Figure 209) The old name for this tab is<Cut ROM>
    Figure 209:
    Attached Image

    Now we have a list of all sections in a way understandable for perception (Figure 211).
    Figure 211:
    Attached Image

  • It is necessary to perform the conversion of the RESERVED sections to their starting addresses from the end, not from the beginning.
    That is, if the starting address is specified as 0xFFFF0084, then this is from the end of the ROM file. That is, FFFF is a minus type. In order to calculate the negative value, you need to know and specify the full amount of memory.
    Now it is calculated automatically, based on the PGPT section. In the PMT section, this information is not available, so you have to manually enter the full amount of memory based on the SP Flash Tool information. (ie see Figure 207).
  • You must also rename the section names. To do this, poke the right mouse button on the table and select<Rename section titles ..>(Figure 219)
    *** Note: If this item passes with an error, then the error occurs only on new platforms MT67xx. The thing is that there is a division of memory on EMMC_BOOT_1, EMMC_BOOT_2, EMMC_RPMB, EMMC_USER. All data is stored in EMMC_USER, and Preloader is in EMMC_BOOT_1, and since the image is selected EMMC_USER, then there is no Preloader, you simply need to manually point to the Preloader that you have already pulled (i.e. double-click on the Preloader. ( Figure 219))
    Figure 219:
    Attached Image

  • You must perform another check on EXT4_IMG. To do this, poke the right mouse button on the table and select<Checks> -><Check for EXT4_IMG>.
    The program looks at the ROM at the start of all partitions and defines the partition on the file system: EXT4_IMG, UBI_IMG, NORMAL_ROM.
  • Create scatter file:
    Create a scatter file:
    Open the tab:<Scatter of the first version:>, push the button<Create Scatter File>, choose the name and save.
    If the button is not active, then:
    Open the tab:<Scatter version two:>, Check if the program correctly identified the platform (if not correctly, then fix it).
    Push the button<Create Scatter File>, choose the name and save.
  • Splitting a ROM file into sections:
    Now you need to divide the ROM file into sections, to do this, open the tab<Cut ROM>and press a button<Cut ROM to folder>, we choose the place of conservation and wait for the completion of the separation process.
  • Use as directed. (Mounting partitions, extracting the data you need, and so on)
    At your choice, other programs. :)

If the device turns on:
If the device turns on, there is no root
If the phone turns on and there is no Root right
So for this we will need to connect the included device to the PC, install the necessarydrivers (VCOM) for phone, and download the program Wwr_mtk
It is advisable before starting any actions, to go to Recovery on the device itself, there is nothing special to do there, just when you go into it, if Recovery is a stock, it creates a Log file in the memory cache of the device, which can be useful.
    The procedure is as follows:
  • 1. In the device, you must activate the developer mode. In developer mode, enable<USB debugging>. Confirm the PC connection to the device, on the device itself.
  • 2. In the program WwR_MTK get information about the device.
  • 3. Create an empty scatter file.
  • 4. In the SP Flash Tool, read the block containing the Preloader.
  • 5. In the SP Flash Tool, read the entire memory dump (Make a full backup of the firmware from the phone).
  • 6. In the program WwR_MTK create scatter file, create firmware.

    Attention!!! This method is applicable to devices only on the MTK platform. And having a partition table: Dumchar_info or Partinfo! Be careful. Clause 2.1. this instruction, i.e. below

    Now in more detail:
  • 1. In the device, you must activate the developer mode:
    1.1. Almost everyone knows how to do it, in each device it is done differently, it all depends on the version of Android. So it would be better if you read the profile topic on your device.
    Or, for example: In order to activate the developer mode, go to: "Settings" - "About phone" - click on the build number 7 times. In the developer settings, enable USB debugging. When you connect a USB cable, select Charging Only.
    1.2. If the PC is successfully connected to the device, the device will display a request for actions from the PC;
  • 2. In the program WwR_MTK get information about the device:
    2.1. In the program WwR_MTK open tab<Adb>push button<To plug>. If the drivers have been installed correctly, the program will see the device and display information about it.
    I repeat again:This method is applicable only to devices on the MTK platform and having a partition table Dumchar_info and Partinfo. See here if there is a partition table (Figure 224).
    Picture_224
    Attached Image

  • 3. Create an empty scatter file:
    3.1. Go to tab<Autopilot>or<Empty scatter file>, make sure that the platform type is selected correctly, then click on the button<Create and save as ..>(AT<Autopilot>this is the first item).
  • 4. In the SP Flash Tool, read the block containing the Preloader .:
    4.1. To do this, in the SP Flash Tool, select this empty scatter file in the tab<Download>in field<Scatter-loading>, then go to the tab<ReadBack>Push the button<Add>. A new line will appear below. We click on it twice and select the storage location of the so-called ROM_0 block.
    Push<Save>, then a selection of values ​​appears on which the SP Flash Tool should read the memory from the device (phone or tablet).
    Next, select for EMMC_BOOT_1:
    Type - HEX
    Region: - EMMC_BOOT_1, (If there is such a choice), or EMMC_USER.
    Start Address: - choose 0x0000000000000000, that is, the very beginning.
    Lenght: - choose 0x0000000000100000, i.e. length.
    In details
    Usually on new platforms (MT67xx and MT6580) the Preloader is in EMMC_BOOT_1, and all other data is in EMMC_USER.
    We need a region with Preloader. It is usually located at the very beginning of the phone’s memory and does not exceed the size in megabytes (I have not seen the Preloader more than 200 Kb).
    1 Megabyte: 1048576 bytes in decimal form
    1 Megabyte: 0x100000 in hexadecimal form
    (0x parameter - indicates that the number is presented in hexadecimal)
    You can specify and:
    512 KB: 0x80000
    256 KB: 0x40000.
    You can specify more than it is, nothing terrible will happen.
    Therefore, in the SP Flash Tool, select the values:
    Where<Start Address:>- choose<0x00000000000000>, ie the very beginning
    and length:<Lenght:> - <0x0000000000100000>
    Next, click<Ok>and<Read back>. And we completely connect the phone to the computer. (Figure 200, 201).
    Figure 200, if the memory in the EMMC device:
    Attached Image
    Figure 201, if the memory in the NAND device:
    Attached Image
    4.2. If an error occurs (Figure 202), then we change in WwR_MTK the type of processor shown by the SP Flash Tool. Repeat the action from paragraph 4.1.
    Figure 202:
    Attached Image
    4.3. If an error occurs (Figure 203), then we change the type of memory shown by the SP Flash Tool in WwR_MTK. Repeat the action from paragraph 4.1.
    Figure 203:
    Attached Image
    4.4. If successful, a window with a green circle and a check mark should come out (Figure 204).
    Figure 204:
    Attached Image

  • 5. In the SP Flash Tool, read the entire memory dump (Make a full backup of the firmware from the phone):
    5.1. Now you need to read the full backup from the phone.
    5.2. Preferably tab<ReadBack>remove checkbox from ROM_0.
    5.3. Go to the tab<ReadBack>Push the button<Add>. Another line will appear in the table below, just click on it and indicate the location of the file to be saved. Then there is a choice of values ​​by which the SP Flash Tool should read the memory from the device. Choose:
    Type - HEX,
    Region: - EMMC_USER
    Start Address: - choose 0x0000000000000000, that is, the very beginning,
    Lenght: - choose the length 0x ................, which we considered in WwR_MTK in the tab<Adb>In the information field:<Full ROM memory: 0x1D2000000 (7456 MB)>. See Figure 225.
    Figure 225:
    Attached Image
    5.4. Next, click<Ok>and<Read back>. And we completely connect the phone to the computer. (Figure 208-1).
    Figure 208-1:
    Attached Image
    5.5. The process of reading the full dump of the phone will go. The process is not fast. If successful, a window with a green circle and a check mark should come out (Figure 204).
    Figure 204:
    Attached Image

  • 6. In the program WwR_MTK create a scatter file, create firmware:
  • 6.1. Option 1: Select the ROM_1 file (EMMC_USER) in<Autopilot>, the instruction is above:
  • 6.2. Option 2: If there is a partition table (Figure 226).
    Figure 226:
    Attached Image
    You can create a scatter file, select a ROM file and create a firmware:
    • To do this in the tab<Adb>there is a tab<List of sections, assemble firmware>- we go there. Push button<List of sections (Dumchar_info)>or<List of sections (Partinfo)>.
    • If everything is fine, then you will be on the tab<Scatter file>If there is a need to save only certain sections, then you need to uncheck the boxes that you do not need. Then go back to the tab<Adb>.
    • Next, press the button<Select ROM from SPFT>and select ROM_1 (EMMC_USER), if the program requests a file with EMMC_BOOT_1, specify ROM_0 containing the Preloader. The program will perform all necessary actions.
    • Next, press the button<Build firmware (backup)>select a folder to save and wait for the program to end.
If everything went well, then you have a full ROM of the entire memory of the device. The assembled firmware, in it the scatter file and all other sections.

The following method is generally a separate instruction, because you can remove backup partitions from any device that has Root rights:
If the device is on your MTK platform, and not one of the instructions above did not help to assemble the firmware, or for some reason cannot work with the SP Flash Tool.
If not MTK, then you can perform a backup of the sections, why they are to you and how you will use them all the same. Everyone decides for himself. At the moment we are talking about backup.
If I have information, how can I continue to use backup from other platforms. I will supplement the instrument and possibly supplement the program.
If the device turns on, root rights are
If the phone turns on and Root rights are there
So for this we will need to connect the included device to the PC, install the necessarydrivers (VCOM) for phone, and download the program Wwr_mtk
It is advisable before starting any actions, to go to Recovery on the device itself, there is nothing special to do there, just when you go into it, if Recovery is a stock, it creates a Log file in the memory cache of the device, which can be useful.
And insert the flash memory, any size will fit even 128 megabytes.
    The procedure is as follows:
  • 1. In the device, you must activate the developer mode. In developer mode, enable<USB debugging>. Confirm the PC connection to the device, on the device itself.
  • 2. In the program WwR_MTK get information about the device.
  • 3. In the program WwR_MTK run backup sections.

    Now in more detail:
  • 1. In the device, you must activate the developer mode:
    1.1. Almost everyone knows how to do it, in each device it is done differently, it all depends on the version of Android. So it would be better if you read the profile topic on your device.
    Or, for example: In order to activate the developer mode, go to: "Settings" - "About phone" - click on the build number 7 times. In the developer settings, enable USB debugging. When you connect a USB cable, select Charging Only.
    1.2. If the PC is successfully connected to the device, the device will display a request for actions from the PC;
  • 2. In the program WwR_MTK get information about the device:
    2.1. In the program WwR_MTK open tab<Adb>push button<To plug>. If the drivers have been installed correctly, the program will see the device and display information about it (Figure 224).
    Picture_224
    Attached Image

  • 3. In the WwR_MTK program, backup the required partitions:
    3.1. Select a tab<Backup>, we are convinced about the presence of valid root rights.
    3.2. If we do not understand, what is needed<Buffer size>and<Place save buffer>- it is better to leave as the program itself has chosen.
    In detail
    The buffer size is needed to read blocks from the device to the size of this buffer, that is, for example: if the System size is 800 MB and the buffer size is 16 MB, the program subtracts 50 blocks from the System section and merges it into one section.
    This is necessary so that the user does not think that the program is frozen. And so that the program itself also did not think that it hangs.
    The place to save the buffer is better to choose a flash drive, in the system it almost always goes like: / sdcard. If the flash drive was not at hand, the device’s internal memory is usually used.

    3.3. Choice of method: The program itself chooses a more normal method, so it is better to leave the method chosen by default.
    3.4. Push the button<Prepare and check ..>, The program will do everything automatically, then the tab should open<Scatter file>with the names of sections, their starting positions and lengths, as well as their availability for saving.
    3.5. Next, remove the check boxes from the sections that are not needed for backup.
    3.6. Go to the tab<Adb>and click on the button<Select a folder and start ..>, We choose the place to save the backup, preferably an empty folder, and wait for the completion of the preservation work.
    3.7. If the device is on the MTK platform, you must save the scatter file. Automatically this is not done. So, you need to go to the tab<Scatter file>.
    Open the tab:<Scatter of the first version:>, push the button<Create Scatter File>, choose the name and save.
    If the button is not active, then:
    Open the tab:<Scatter version two:>, Check if the program correctly identified the platform (if not correctly, then fix it).
    Push the button<Create Scatter File>, choose the name and save.

    Now more about backup methods:
    Method 1 (Dumchar_info)
    For this method, the following commands must be executed in ADB:
    • 1. Dumchar_info. Based on this information, the program knows from which position to start copying, the size of the sections and to which block the section belongs:
      >>adb shell cat / proc / dumchar_info
      Part_Name Size StartAddr Type MapTo
      preloader 0x0000000000600000 0x000000000000000000 2 / dev / misc-sd
      mbr 0x0000000000080000 0x000000000000000000 2 / dev / block / mmcblk0
      ebr1 0x0000000000080000 0x0000000000080000 2 / dev / block / mmcblk0p1
      pmt 0x0000000000400000 0x0000000000100000 2 / dev / block / mmcblk0
      pro_info 0x0000000000300000 0x0000000000500000 2 / dev / block / mmcblk0
      nvram 0x0000000000500000 0x0000000000800000 2 / dev / block / mmcblk0
      protect_f 0x0000000000a00000 0x0000000000d00000 2 / dev / block / mmcblk0p2
      protect_s 0x0000000000a00000 0x0000000001700000 2 / dev / block / mmcblk0p3
      seccfg 0x0000000000020000 0x0000000002100000 2 / dev / block / mmcblk0
      uboot 0x0000000000060000 0x0000000002120000 2 / dev / block / mmcblk0
      bootimg 0x0000000000600000 0x0000000002180000 2 / dev / block / mmcblk0
      recovery 0x0000000000600000 0x0000000002780000 2 / dev / block / mmcblk0
      sec_ro 0x0000000000600000 0x0000000002d80000 2 / dev / block / mmcblk0p4
      misc 0x0000000000080000 0x0000000003380000 2 / dev / block / mmcblk0
      logo 0x0000000000300000 0x0000000003400000 2 / dev / block / mmcblk0
      ebr2 0x0000000000080000 0x0000000003700000 2 / dev / block / mmcblk0
      expdb 0x0000000000a00000 0x0000000003780000 2 / dev / block / mmcblk0
      android 0x0000000028a00000 0x0000000004180000 2 / dev / block / mmcblk0p5
      cache 0x0000000007e00000 0x000000002cb80000 2 / dev / block / mmcblk0p6
      usrdata 0x0000000040000000 0x0000000034980000 2 / dev / block / mmcblk0p7
      fat 0x0000000071180000 0x0000000074980000 2 / dev / block / mmcblk0p8
      bmtpool 0x0000000001500000 0x00000000ff9f00a8 2 / dev / block / mmcblk0
      Part_Name: Partition name you should open;
      Size: size of partition
      StartAddr: Start Address of partition;
      Type: Type of partition (MTD = 1, EMMC = 2)
      MapTo: actual device you operate

    • 2. Getprop. Displaying this information helps the program know what platform is being used. And apply it.
      >>adb shell getprop
      [curlockscreen]: [1]
      [dalvik.vm.heapgrowthlimit]: [128m]
      [dalvik.vm.heapsize]: [256m]
      [dalvik.vm.mtk-stack-trace-file]: [/data/anr/mtk_traces.txt]
      [dalvik.vm.stack-trace-file]: [/data/anr/traces.txt]
      [debug.MB.running]: [0]
      [debug.log2sd.defaultpath]: [/ mnt / sdcard]
      [debug.mtklog.netlog.Running]: [0]
      [dev.bootcomplete]: [1]
      [dhcp.ipv6.wlan0.dns1]: [fe80 :: 1]
      [dhcp.ipv6.wlan0.dns2]: []
      [dhcp.ipv6.wlan0.ipaddress]: []
      [dhcp.ipv6.wlan0.leasetime]: []
      [dhcp.ipv6.wlan0.reason]: [INFOREQ]
      [dhcp.ipv6.wlan0.result]: [ok]
      [dhcp.wlan0.dns1]: [192.168.1.1]
      [dhcp.wlan0.dns2]: []
      [dhcp.wlan0.dns3]: []
      [dhcp.wlan0.dns4]: []
      [dhcp.wlan0.gateway]: [192.168.1.1]
      [dhcp.wlan0.ipaddress]: [192.168.1.151]
      [dhcp.wlan0.leasetime]: [86400]
      [dhcp.wlan0.mask]: [255.255.255.0]
      [dhcp.wlan0.pid]: [930]
      [dhcp.wlan0.reason]: [REBOOT]
      [dhcp.wlan0.result]: [ok]
      [dhcp.wlan0.server]: [192.168.1.1]
      [dhcp.wlan0.vendorInfo]: []
      [drm.service.enabled]: [true]
      [external_sd_path]: [/ storage / sdcard1]
      [fmradio.driver.chip]: [3]
      [fmradio.driver.enable]: [1]
      [gps.solution.combo.chip]: [1]
      [gsm.3gswitch]: [1]
      [gsm.baseband.capability2]: [3]
      [gsm.baseband.capability]: [55]
      [gsm.current.phone-type]: [1]
      [gsm.gcf.testmode]: [0]
      [gsm.network.type]: [unknown]
      [gsm.operator.alpha.2]: []
      [gsm.operator.alpha]: []
      [gsm.operator.iso-country.2]: []
      [gsm.operator.iso-country]: []
      [gsm.operator.isroaming.2]: [false]
      [gsm.operator.isroaming]: [false]
      [gsm.operator.numeric.2]: []
      [gsm.operator.numeric]: []
      [gsm.phone.created]: [true]
      [gsm.project.baseband.2]: [HEDY89_WE_JB2_MD1_HSPA_HW (DEFAULT)]
      [gsm.project.baseband]: [HEDY89_WE_JB2_MD1_HSPA_HW (DEFAULT)]
      [gsm.roaming.indicator.needed.2]: [false]
      [gsm.roaming.indicator.needed]: [false]
      [gsm.serial]: [10]
      [gsm.sim.inserted]: [0]
      [gsm.sim.ril.phbready.2]: [true]
      [gsm.sim.ril.phbready]: [false]
      [gsm.sim.state.2]: [ABSENT]
      [gsm.sim.state]: [ABSENT]
      [gsm.siminfo.ready]: [true]
      [gsm.version.baseband]: [MOLY.WR8.W1248.MD.WG.MP.V6, 2013/05/08 11:19]
      [gsm.version.ril-impl]: [mtk gemini ril 1.0]
      [init.svc.662x_launcher]: [running]
      [init.svc.DMAgent]: [running]
      [init.svc.GoogleOtaAgent]: [running]
      [init.svc.NvRAMAgent]: [running]
      [init.svc.adbd]: [running]
      [init.svc.agpsd]: [running]
      [init.svc.bootanim]: [stopped]
      [init.svc.bootlogoupdater]: [stopped]
      [init.svc.ccci2_fsd]: [stopped]
      [init.svc.ccci2_mdinit]: [stopped]
      [init.svc.ccci_fsd]: [running]
      [init.svc.ccci_mdinit]: [running]
      [init.svc.dbus]: [running]
      [init.svc.debuggerd]: [running]
      [init.svc.dhcp6cDNS_wlan0]: [running]
      [init.svc.dhcpcd_wlan0]: [running]
      [init.svc.dpfd]: [running]
      [init.svc.drm]: [running]
      [init.svc.flash_recovery]: [stopped]
      [init.svc.gsm0710muxd]: [running]
      [init.svc.hald]: [running]
      [init.svc.installd]: [running]
      [init.svc.keystore]: [running]
      [init.svc.matv]: [running]
      [init.svc.mdlogger]: [running]
      [init.svc.media]: [running]
      [init.svc.mobile_log_d]: [running]
      [init.svc.msensord]: [stopped]
      [init.svc.mtkGD]: [running]
      [init.svc.mtkbt]: [running]
      [init.svc.netd]: [running]
      [init.svc.netdiag]: [running]
      [init.svc.nvram_daemon]: [stopped]
      [init.svc.p2p_supplicant]: [running]
      [init.svc.permission_check]: [stopped]
      [init.svc.poad]: [stopped]
      [init.svc.pq]: [stopped]
      [init.svc.pvrsrvctl]: [stopped]
      [init.svc.ril-daemon]: [running]
      [init.svc.sbchk]: [stopped]
      [init.svc.servicemanager]: [running]
      [init.svc.stp_dump]: [running]
      [init.svc.surfaceflinger]: [running]
      [init.svc.thermal]: [running]
      [init.svc.thermal_manager]: [stopped]
      [init.svc.ueventd]: [running]
      [init.svc.vold]: [running]
      [init.svc.vtservice]: [running]
      [init.svc.wlanLoader]: [stopped]
      [init.svc.xlogboot]: [stopped]
      [init.svc.xlogdebug changes]: [stopped]
      [init.svc.zygote]: [running]
      [internal_sd_path]: [/ storage / sdcard0]
      [launcher2.allappsgrid]: [3d_20]
      [launcherplus.allappsgrid]: [2d]
      [mediatek.wlan.chip]: [MT6628]
      [mediatek.wlan.ctia]: [0]
      [mediatek.wlan.module.postfix]: [_mt6628]
      [mux.report.case]: [0]
      [net.bt.name]: [Android]
      [net.change]: [net.dnschange]
      [net.dns1]: [192.168.1.1]
      [net.dnschange]: [2]
      [net.hostname]: [android-c17da8d956f3a9f8]
      [net.ipv6.dns1]: [fe80 :: 928d: 78ff: fe0a: 7480]
      [net.qtaguid_enabled]: [1]
      [net.tcp.buffersize.default]: [4096,87380,110208,4096,16384,110208]
      [net.tcp.buffersize.edge]: [4093,26280,35040,4096,16384,35040]
      [net.tcp.buffersize.evdo]: [4094,87380,262144,4096,16384,262144]
      [net.tcp.buffersize.gprs]: [4092,8760,11680,4096,8760,11680]
      [net.tcp.buffersize.hsdpa]: [4094,87380,262144,4096,16384,262144]
      [net.tcp.buffersize.hspa]: [4094,87380,262144,4096,16384,262144]
      [net.tcp.buffersize.hspap]: [4094,87380,1220608,4096,16384,1220608]
      [net.tcp.buffersize.hsupa]: [4094,87380,262144,4096,16384,262144]
      [net.tcp.buffersize.lte]: [524288,1048576,2097152,262144,524288,1048576]
      [net.tcp.buffersize.umts]: [4094,87380,110208,4096,16384,110208]
      [net.tcp.buffersize.wifi]: [524288,1048576,2097152,262144,524288,1048576]
      [net.wlan0.dns1]: [49.0.0.0]
      [net.wlan0.dns2]: []
      [nvram_init]: [Ready]
      [persist.first_boot]: [0]
      [persist.mtk.aee.aed]: [on]
      [persist.mtk.wcn.combo.chipid]: [0x6628]
      [persist.radio.default_sim]: [0]
      [persist.radio.default_sim_mode]: [12]
      [persist.radio.fd.counter]: [15]
      [persist.radio.fd.off.counter]: [5]
      [persist.radio.fd.off.r8.counter]: [5]
      [persist.radio.fd.r8.counter]: [15]
      [persist.service.acm.enable]: []
      [persist.service.adb.enable]: []
      [persist.sys.country]: [RU]
      [persist.sys.first_time_boot]: [false]
      [persist.sys.language]: [ru]
      [persist.sys.launcher-reset]: [2]
      [persist.sys.localevar]: []
      [persist.sys.mute.state]: [2]
      [persist.sys.profiler_ms]: [0]
      [persist.sys.screen.size]: [800x480]
      [persist.sys.sd.defaultpath]: [/ storage / sdcard0]
      [persist.sys.timezone]: [Asia / Shanghai]
      [persist.sys.usb.config]: [mass_storage, adb]
      [ril.current.share_modem]: [2]
      [ril.external.md]: [0]
      [ril.fd.mode]: [1]
      [ril.first.md]: [1]
      [ril.flightmode.poweroffMD]: [1]
      [ril.iccid.sim1]: [N / A]
      [ril.iccid.sim2]: [N / A]
      [ril.radiooff.poweroffMD]: [0]
      [ril.ready.sim]: [false]
      [ril.specific.sm_cause]: [0]
      [ril.telephony.mode]: [1]
      [rild.libargs]: [-d / dev / ttyC0]
      [rild.libpath]: [/system/lib/mtk-ril.so]
      [ro.allow.mock.location]: [0]
      [ro.audio.silent]: [0]
      [ro.baseband]: [unknown]
      [ro.board.platform]: [exynos5]
      [ro.boot.serialno]: [0123456789ABCDEF]
      [ro.bootloader]: [unknown]
      [ro.bootmode]: [unknown]
      [ro.build.characteristics]: [default]
      [ro.build.date.utc]: [1373287134]
      [ro.build.date]: [2013 年 07 月 08 日 星期一 20:38:54 CST]
      [ro.build.description]: [ja3gzs-user 4.2.2 JDQ39 I9500ZSUAMDE release-keys]
      [ro.build.display.id]: [JDQ39.I9500ZSUAMDF]
      [ro.build.fingerprint]: [samsung / ja3gzs / ja3g: 4.2.2 / JDQ39 / I9500ZSUAMDE: user / release-keys]
      [ro.build.flavor]: []
      [ro.build.host]: [SEP-92]
      [ro.build.id]: [JDQ39]
      [ro.build.product]: [ja3gzs]
      [ro.build.tags]: [test-keys]
      [ro.build.type]: [user]
      [ro.build.user]: [se.infra]
      [ro.build.version.codename]: [REL]
      [ro.build.version.incremental]: [I9500ZSUAMDF]
      [ro.build.version.release]: [4.2.9]
      [ro.build.version.sdk]: [17]
      [ro.camera.sound.forced]: [0]
      [ro.config.alarm_alert]: [Good_Morning.ogg]
      [ro.config.notification_sound]: [S_Whistle.ogg]
      [ro.config.ringtone]: [S_Over_the_horizon.ogg]
      [ro.crypto.fs_flags]: [0x00000406]
      [ro.crypto.fs_mnt_point]: [/ data]
      [ro.crypto.fs_options]: [noauto_da_alloc, discard]
      [ro.crypto.fs_real_blkdev]: [/ emmc @ usrdata]
      [ro.crypto.fs_type]: [ext4]
      [ro.crypto.state]: [unencrypted]
      [ro.custom.build.version]: [I9868.I9868.02.02.A.A-V05.3-0708]
      [ro.debuggable]: [0]
      [ro.factorytest]: [0]
      [ro.hardware]: [universal5410]
      [ro.mediatek.chip_ver]: [S01]
      [ro.mediatek.gemini_support]: [true]
      [ro.mediatek.platform]: [MT6589]
      [ro.mediatek.version.branch]: [ALPS.JB2.MP]
      [ro.mediatek.version.release]: [ALPS.JB2.MP.V1.2]
      [ro.mediatek.wlan.p2p]: [1]
      [ro.mediatek.wlan.wsc]: [1]
      [ro.mount.fs]: [EXT4]
      [ro.mtprof.disable]: [1]
      [ro.opengles.version]: [131072]
      [ro.product.board]: [smdk4x12]
      [ro.product.brand]: [samsung]
      [ro.product.cpu.abi2]: [armeabi]
      [ro.product.cpu.abi]: [armeabi-v7a]
      [ro.product.device]: [t03g]
      [ro.product.locale.language]: [en]
      [ro.product.locale.region]: [US]
      [ro.product.manufacturer]: [samsung]
      [ro.product.model]: [GT-I9500]
      [ro.product.name]: [t03gzs]
      [ro.revision]: [0]
      [ro.runtime.firstboot]: [1522389798976]
      [ro.secure]: [1]
      [ro.serialno]: [0123456789ABCDEF]
      [ro.sf.hwrotation]: [0]
      [ro.sf.lcd_density]: [240]
      [ro.sys.usb.bicr]: [yes]
      [ro.sys.usb.charging.only]: [yes]
      [ro.sys.usb.mtp.whql.enable]: [0]
      [ro.sys.usb.storage.type]: [mtp, mass_storage]
      [ro.wifi.channels]: []
      [ro.zygote.preload.enable]: [0]
      [service.bootanim.exit]: [1]
      [supolicy.loaded]: [1]
      [sys.boot.reason]: [0]
      [sys.boot_completed]: [1]
      [sys.ipo.pwrdncap]: [2]
      [sys.ipowin.done]: [1]
      [sys.settings_system_version]: [2]
      [sys.usb.config]: [mass_storage, adb]
      [sys.usb.state]: [mass_storage, adb]
      [sys.usb.vid]: [0BB4]
      [system_init.startsurfaceflinger]: [0]
      [vold.post_fs_data_done]: [1]
      [vold_swap_state]: [0]
      [wifi.direct.interface]: [p2p0]
      [wifi.interface]: [wlan0]
      [wifi.tethering.interface]: [ap0]
      [wlan.driver.status]: [ok]

    • 3. Next, the program checks each section for accessibility:
      >>adb shell ls -l / dev / preloader
      crw-r ----- root system 234, 0 2018-03-30 14:02 preloader

      >>adb shell ls -l / dev / mbr
      crw ------- root root 234, 1 2018-03-30 14:02 mbr

      >>adb shell ls -l / dev / block / mmcblk0p1
      brw ------- root root 179, 1 2018-03-30 14:02 mmcblk0p1

      >>adb shell ls -l / dev / pmt
      crw ------- root root 234, 3 2018-03-30 14:02 pmt

      >>adb shell ls -l / dev / pro_info
      crw-rw ---- root system 234, 4 2018-03-30 14:02 pro_info

      >>adb shell ls -l / dev / nvram
      crw-rw ---- root system 234, 5 2018-03-30 14:02 nvram

      >>adb shell ls -l / dev / block / mmcblk0p2
      brw-r ----- root system 179, 2 2018-03-30 14:02 mmcblk0p2

      >>adb shell ls -l / dev / block / mmcblk0p3
      brw ------- root root 179, 3 2018-03-30 14:02 mmcblk0p3

      >>adb shell ls -l / dev / seccfg
      crw-rw ---- root system 234, 8 2018-03-30 14:02 seccfg

      >>adb shell ls -l / dev / uboot
      crw ------- root root 234, 9 2018-03-30 14:02 uboot

      >>adb shell ls -l / dev / bootimg
      crw-r ----- root system 234, 10 2018-03-30 14:02 bootimg

      >>adb shell ls -l / dev / recovery
      crw-r ----- root system 234, 11 2018-03-30 14:02 recovery

      >>adb shell ls -l / dev / block / mmcblk0p4
      brw ------- root root 179, 4 2018-03-30 14:02 mmcblk0p4

      >>adb shell ls -l / dev / misc
      crw-rw ---- root system 234, 13 2018-03-30 14:02 misc

      >>adb shell ls -l / dev / logo
      crw ------- root root 234, 14 2018-03-30 14:02 logo

      >>adb shell ls -l / dev / ebr2
      crw ------- root root 234, 15 2018-03-30 14:02 ebr2

      >>adb shell ls -l / dev / expdb
      crw ------- root root 234, 16 2018-03-30 14:02 expdb

      >>adb shell ls -l / dev / block / mmcblk0p5
      brw ------- root root 179, 5 2018-03-30 14:02 mmcblk0p5

      >>adb shell ls -l / dev / block / mmcblk0p6
      brw ------- root root 179, 6 2018-03-30 14:02 mmcblk0p6

      >>adb shell ls -l / dev / block / mmcblk0p7
      brw ------- root root 179, 7 2018-03-30 14:02 mmcblk0p7

      >>adb shell ls -l / dev / block / mmcblk0p8
      brw ------- root root 179, 8 2018-03-30 14:02 mmcblk0p8

      >>adb shell ls -l / dev / bmtpool
      crw ------- root root 234, 21 2018-03-30 14:02 bmtpool

    • 4. When copying a partition, it uses exactly the blocks specified in<Scatter file>in the table:<Block:>
    • 5. Copying occurs in stages. I.e:
      • If the partition is smaller than the size of the buffer specified in the program, then the partition is copied entirely to the memory card.
      • Then from the memory card is copied to the PC.
      • And removed from the memory card.

      • If the partition is larger than the size of the buffer specified in the program, then the program calculates the ratio of the buffer and the size of the partition.
        Ie for example, the partition has 156 megabytes, and the buffer is 16 megabytes, then the program will set the buffer to 13 megabytes, respectively 12 blocks of 13 megabytes are obtained (12 * 13 = 156)
      • And it will copy blocks from a partition 12 times in size of 13 megabytes to a memory card.
      • Then on the PC, merge the blocks.
      • And delete blocks from the memory card.
    Method 2 (Full_ROM)
    For this method, the presence of a block - mmcblk0:
    • The method is not done to the end, and it simply copies the mmcblk0 block in stages, dividing it into blocks.

    Method 3 (Partinfo, Partitions, emmc)
    For this method, the following commands must be executed in ADB:
    • 1. Partinfo.
      >>adb shell cat / proc / partinfo
      Name Start Size
      pgpt 0x0000000000000000 0x0000000000080000
      proinfo 0x0000000000800000 0x0000000000680000
      nvram 0x0000000000e80000 0x0000000000500500000
      protect1 0x0000000001380000 0x0000000000a00000
      protect2 0x0000000001d80000 0x0000000000a00000
      para 0x0000000002780000 0x0000000000080000
      lk 0x0000000002800000 0x0000000000800000
      logo 0x0000000003000000 0x0000000000800000
      boot 0x0000000003800000 0x0000000001000000
      recovery 0x0000000004800000 0x0000000001000000
      oemkeystore 0x0000000005800000 0x0000000000800000
      secro 0x0000000006000000 0x0000000000800000
      keystore 0x0000000006800000 0x0000000000800000
      custpack 0x0000000007000000 0x0000000038000000
      seccfg 0x000000003f000000 0x0000000000800000
      expdb 0x000000003f800000 0x0000000001000000
      mobile_info 0x0000000040800000 0x0000000000800000
      frp 0x0000000041000000 0x0000000000800000
      nvdata 0x0000000041800000 0x0000000002000000
      metadata 0x0000000043800000 0x0000000002000000
      system 0x0000000045800000 0x000000004e800000
      cache 0x0000000094000000 0x0000000007000000
      userdata 0x000000009b000000 0x0000000133480000
      otp 0x00000001ce480000 0x0000000002b00000
      flashinfo 0x00000001d0f80000 0x0000000001000000
      sgpt 0x00000001d1f80000 0x0000000000080000

    • 2. Partitions.
      >>adb shell cat / proc / partitions
      major minor #blocks name
      254 0 499712 zram0
      7 0 21796 loop0
      179 0 7634944 mmcblk0
      179 1 6656 mmcblk0p1
      179 2 5120 mmcblk0p2
      179 3 10240 mmcblk0p3
      179 4 10240 mmcblk0p4
      179 5 512 mmcblk0p5
      179 6,8192 mmcblk0p6
      179 7 8192 mmcblk0p7
      179 8 16384 mmcblk0p8
      179 9 16384 mmcblk0p9
      179 10 8192 mmcblk0p10
      179 11 8192 mmcblk0p11
      179 12,8192 mmcblk0p12
      179 13 917504 mmcblk0p13
      179 14 8192 mmcblk0p14
      179 15 16384 mmcblk0p15
      179 16 8192 mmcblk0p16
      179 17 8192 mmcblk0p17
      179 18 32768 mmcblk0p18
      179 19 32768 mmcblk0p19
      179 20 1286144 mmcblk0p20
      179 21 114688 mmcblk0p21
      179 22 5034496 mmcblk0p22
      179 23 44032 mmcblk0p23
      179 24 16384 mmcblk0p24
      179 96 512 mmcblk0rpmb
      179 64 4096 mmcblk0boot1
      179 32 4096 mmcblk0boot0

    • 3. Emmc.
      >>adb shell cat / proc / emmc
      partno: start_sect nr_sects partition_name
      emmc_p1: 00004000 00003400 "proinfo"
      emmc_p2: 00007400 00002800 "nvram"
      emmc_p3: 00009c00 00005000 "protect1"
      emmc_p4: 0000ec00 00005000 "protect2"
      emmc_p5: 00013c00 00000400 "para"
      emmc_p6: 00014000 00004000 "lk"
      emmc_p7: 00018000 00004000 "logo"
      emmc_p8: 0001c000 00008000 "boot"
      emmc_p9: 00024000 00008000 "recovery"
      emmc_p10: 0002c000 00004000 "oemkeystore"
      emmc_p11: 00030000 00004000 "secro"
      emmc_p12: 00034000 00004000 "keystore"
      emmc_p13: 00038000 001c0000 "custpack"
      emmc_p14: 001f8000 00004000 "seccfg"
      emmc_p15: 001fc000 00008000 "expdb"
      emmc_p16: 00204000 00004000 "mobile_info"
      emmc_p17: 00208000 00004000 "frp"
      emmc_p18: 0020c000 00010000 "nvdata"
      emmc_p19: 0021c000 00010000 "metadata"
      emmc_p20: 0022c000 00274000 "system"
      emmc_p21: 004a0000 00038000 "cache"
      emmc_p22: 004d8000 0099a400 "userdata"
      emmc_p23: 00e72400 00015800 "otp"
      emmc_p24: 00e87c00 00008000 "flashinfo"

    • 4. The program itself connects information from all three conclusions, checks the sizes of blocks, the names of sections.
    • 5. When copying a partition, it uses exactly the blocks specified in<Scatter file>in the table:<Block:>
    • 6. Copying occurs in stages. I.e:
      • If the partition is smaller than the size of the buffer specified in the program, then the partition is copied entirely to the memory card.
      • Then from the memory card is copied to the PC.
      • And removed from the memory card.

      • If the partition is larger than the size of the buffer specified in the program, then the program calculates the ratio of the buffer and the size of the partition.
        Ie for example, the partition has 156 megabytes, and the buffer is 16 megabytes, then the program will set the buffer to 13 megabytes, respectively 12 blocks of 13 megabytes are obtained (12 * 13 = 156)
      • And it will copy blocks from a partition 12 times in size of 13 megabytes to a memory card.
      • Then on the PC, merge the blocks.
      • And delete blocks from the memory card.

    • 7. Getprop. Displaying this information helps the program know what platform is being used. And apply it.
      >>adb shell getprop
      [ro.sf.hwrotation]: [0]
      [ro.sf.lcd_density]: [320]
      [ro.adb.secure]: [1]
      [ro.apn.presetapn.edit.flag]: [true]
      [ro.com.idea.SP.call]: [false]
      [ro.com.google.gmsversion]: [5.1_r2]
      [ro.com.google.clientidbase]: [android-alcatel]
      [ro.com.google.clientidbase.am]: [android-alcatel]
      [ro.com.google.clientidbase.ms]: [android-alcatel]
      [ro.com.google.clientidbase.yt]: [android-alcatel]
      [ro.com.google.clientidbase.gmm]: [android-alcatel]
      [ro.com.android.dateformat]: [MM-dd-yyyy]
      [ro.com.android.mobiledata]: [false]
      [ro.com.android.dataroaming]: [0]
      [ro.com.android.dataroaming2]: [0]
      [ro.def.mms.autolink.extra]: [0]
      [ro.def.svn.countrycode]: []
      [ro.def.show.sim.change.dialog]: [true]
      [ro.def.show.plmn]: [1]
      [ro.def.russia.num.match.rule]: [0]
      [ro.def.browser]: [0]
      [ro.def.software.svn]: [01001]
      [ro.def.software.version]: [01001]
      [ro.def.phonenumber.Telstra]: [false]
      [ro.def.TelephonyProvider.match]: [0]
      [ro.dtv.support]: [false]
      [ro.frp.pst]: [/dev/block/platform/mtk-msdc.0/by-name/frp]
      [ro.oma.cp.authen_mandatory]: [true]
      [ro.oma.cp.userpin_acceptable]: [true]
      [ro.ssv.enabled]: [false]
      [ro.ssv.mccmncspnlist]: [20416-998 (main), 20416-999]
      [ro.ssv.config_operator]: [none]
      [ro.ssv.diag_sel_config]: [1]
      [ro.sys.usb.mtp.whql.enable]: [0]
      [ro.sys.usb.bicr]: [yes]
      [ro.sys.usb.storage.type]: [mtp, mass_storage]
      [ro.sys.usb.charging.only]: [yes]
      [ro.boot.hardware]: [mt6580]
      [ro.boot.serialno]: [65TW556D99999999 [128m]]


    Method 4 (Partinfo, Partitions, Auto)
    For this method, the following commands must be executed in ADB:
    • 1. Partinfo.
      >>adb shell cat / proc / partinfo
      Name Start Size
      pgpt 0x0000000000000000 0x0000000000080000
      proinfo 0x0000000000800000 0x0000000000680000
      nvram 0x0000000000e80000 0x0000000000500500000
      protect1 0x0000000001380000 0x0000000000a00000
      protect2 0x0000000001d80000 0x0000000000a00000
      para 0x0000000002780000 0x0000000000080000
      lk 0x0000000002800000 0x0000000000800000
      logo 0x0000000003000000 0x0000000000800000
      boot 0x0000000003800000 0x0000000001000000
      recovery 0x0000000004800000 0x0000000001000000
      oemkeystore 0x0000000005800000 0x0000000000800000
      secro 0x0000000006000000 0x0000000000800000
      keystore 0x0000000006800000 0x0000000000800000
      custpack 0x0000000007000000 0x0000000038000000
      seccfg 0x000000003f000000 0x0000000000800000
      expdb 0x000000003f800000 0x0000000001000000
      mobile_info 0x0000000040800000 0x0000000000800000
      frp 0x0000000041000000 0x0000000000800000
      nvdata 0x0000000041800000 0x0000000002000000
      metadata 0x0000000043800000 0x0000000002000000
      system 0x0000000045800000 0x000000004e800000
      cache 0x0000000094000000 0x0000000007000000
      userdata 0x000000009b000000 0x0000000133480000
      otp 0x00000001ce480000 0x0000000002b00000
      flashinfo 0x00000001d0f80000 0x0000000001000000
      sgpt 0x00000001d1f80000 0x0000000000080000

    • 2. Partitions.
      >>adb shell cat / proc / partitions
      major minor #blocks name
      254 0 499712 zram0
      7 0 21796 loop0
      179 0 7634944 mmcblk0
      179 1 6656 mmcblk0p1
      179 2 5120 mmcblk0p2
      179 3 10240 mmcblk0p3
      179 4 10240 mmcblk0p4
      179 5 512 mmcblk0p5
      179 6,8192 mmcblk0p6
      179 7 8192 mmcblk0p7
      179 8 16384 mmcblk0p8
      179 9 16384 mmcblk0p9
      179 10 8192 mmcblk0p10
      179 11 8192 mmcblk0p11
      179 12,8192 mmcblk0p12
      179 13 917504 mmcblk0p13
      179 14 8192 mmcblk0p14
      179 15 16384 mmcblk0p15
      179 16 8192 mmcblk0p16
      179 17 8192 mmcblk0p17
      179 18 32768 mmcblk0p18
      179 19 32768 mmcblk0p19
      179 20 1286144 mmcblk0p20
      179 21 114688 mmcblk0p21
      179 22 5034496 mmcblk0p22
      179 23 44032 mmcblk0p23
      179 24 16384 mmcblk0p24
      179 96 512 mmcblk0rpmb
      179 64 4096 mmcblk0boot1
      179 32 4096 mmcblk0boot0

    • 3. The program itself connects information from all two conclusions, checks the size of blocks, the names of sections.
    • 4. When copying a partition, it uses exactly the blocks specified in<Scatter file>in the table:<Block:>
    • 5. Copying occurs in stages. I.e:
      • If the partition is smaller than the size of the buffer specified in the program, then the partition is copied entirely to the memory card.
      • Then from the memory card is copied to the PC.
      • And removed from the memory card.

      • If the partition is larger than the size of the buffer specified in the program, then the program calculates the ratio of the buffer and the size of the partition.
        Ie for example, the partition has 156 megabytes, and the buffer is 16 megabytes, then the program will set the buffer to 13 megabytes, respectively 12 blocks of 13 megabytes are obtained (12 * 13 = 156)
      • And it will copy blocks from a partition 12 times in size of 13 megabytes to a memory card.
      • Then on the PC, merge the blocks.
      • And delete blocks from the memory card.

    • 6. Getprop. Displaying this information helps the program know what platform is being used. And apply it.
      >>adb shell getprop
      [ro.sf.hwrotation]: [0]
      [ro.sf.lcd_density]: [320]
      [ro.adb.secure]: [1]
      [ro.apn.presetapn.edit.flag]: [true]
      [ro.com.idea.SP.call]: [false]
      [ro.com.google.gmsversion]: [5.1_r2]
      [ro.com.google.clientidbase]: [android-alcatel]
      [ro.com.google.clientidbase.am]: [android-alcatel]
      [ro.com.google.clientidbase.ms]: [android-alcatel]
      [ro.com.google.clientidbase.yt]: [android-alcatel]
      [ro.com.google.clientidbase.gmm]: [android-alcatel]
      [ro.com.android.dateformat]: [MM-dd-yyyy]
      [ro.com.android.mobiledata]: [false]
      [ro.com.android.dataroaming]: [0]
      [ro.com.android.dataroaming2]: [0]
      [ro.def.mms.autolink.extra]: [0]
      [ro.def.svn.countrycode]: []
      [ro.def.show.sim.change.dialog]: [true]
      [ro.def.show.plmn]: [1]
      [ro.def.russia.num.match.rule]: [0]
      [ro.def.browser]: [0]
      [ro.def.software.svn]: [01001]
      [ro.def.software.version]: [01001]
      [ro.def.phonenumber.Telstra]: [false]
      [ro.def.TelephonyProvider.match]: [0]
      [ro.dtv.support]: [false]
      [ro.frp.pst]: [/dev/block/platform/mtk-msdc.0/by-name/frp]
      [ro.oma.cp.authen_mandatory]: [true]
      [ro.oma.cp.userpin_acceptable]: [true]
      [ro.ssv.enabled]: [false]
      [ro.ssv.mccmncspnlist]: [20416-998 (main), 20416-999]
      [ro.ssv.config_operator]: [none]
      [ro.ssv.diag_sel_config]: [1]
      [ro.sys.usb.mtp.whql.enable]: [0]
      [ro.sys.usb.bicr]: [yes]
      [ro.sys.usb.storage.type]: [mtp, mass_storage]
      [ro.sys.usb.charging.only]: [yes]
      [ro.boot.hardware]: [mt6580]
      [ro.boot.serialno]: [65TW556D99999999 [128m]]
    Method 5 (Partinfo, Partitions, by-name)
    For this method, the following commands must be executed in ADB:
    • 1. Partinfo.
      >>adb shell cat / proc / partinfo
      Name Start Size
      pgpt 0x0000000000000000 0x0000000000080000
      proinfo 0x0000000000800000 0x0000000000680000
      nvram 0x0000000000e80000 0x0000000000500500000
      protect1 0x0000000001380000 0x0000000000a00000
      protect2 0x0000000001d80000 0x0000000000a00000
      para 0x0000000002780000 0x0000000000080000
      lk 0x0000000002800000 0x0000000000800000
      logo 0x0000000003000000 0x0000000000800000
      boot 0x0000000003800000 0x0000000001000000
      recovery 0x0000000004800000 0x0000000001000000
      oemkeystore 0x0000000005800000 0x0000000000800000
      secro 0x0000000006000000 0x0000000000800000
      keystore 0x0000000006800000 0x0000000000800000
      custpack 0x0000000007000000 0x0000000038000000
      seccfg 0x000000003f000000 0x0000000000800000
      expdb 0x000000003f800000 0x0000000001000000
      mobile_info 0x0000000040800000 0x0000000000800000
      frp 0x0000000041000000 0x0000000000800000
      nvdata 0x0000000041800000 0x0000000002000000
      metadata 0x0000000043800000 0x0000000002000000
      system 0x0000000045800000 0x000000004e800000
      cache 0x0000000094000000 0x0000000007000000
      userdata 0x000000009b000000 0x0000000133480000
      otp 0x00000001ce480000 0x0000000002b00000
      flashinfo 0x00000001d0f80000 0x0000000001000000
      sgpt 0x00000001d1f80000 0x0000000000080000

    • 2. Partitions.
      >>adb shell cat / proc / partitions
      major minor #blocks name
      254 0 499712 zram0
      7 0 21796 loop0
      179 0 7634944 mmcblk0
      179 1 6656 mmcblk0p1
      179 2 5120 mmcblk0p2
      179 3 10240 mmcblk0p3
      179 4 10240 mmcblk0p4
      179 5 512 mmcblk0p5
      179 6,8192 mmcblk0p6
      179 7 8192 mmcblk0p7
      179 8 16384 mmcblk0p8
      179 9 16384 mmcblk0p9
      179 10 8192 mmcblk0p10
      179 11 8192 mmcblk0p11
      179 12,8192 mmcblk0p12
      179 13 917504 mmcblk0p13
      179 14 8192 mmcblk0p14
      179 15 16384 mmcblk0p15
      179 16 8192 mmcblk0p16
      179 17 8192 mmcblk0p17
      179 18 32768 mmcblk0p18
      179 19 32768 mmcblk0p19
      179 20 1286144 mmcblk0p20
      179 21 114688 mmcblk0p21
      179 22 5034496 mmcblk0p22
      179 23 44032 mmcblk0p23
      179 24 16384 mmcblk0p24
      179 96 512 mmcblk0rpmb
      179 64 4096 mmcblk0boot1
      179 32 4096 mmcblk0boot0

    • 3. The program is looking for a folder (directory) named<by-name>after folder (directory)</ dev / block>. It has an approximate conclusion:
      >>adb shell ls -l / dev / block
      / dev / block: Permission denied

      >>adb shell su -c ls -l / dev / block
      brw ------- root root 253, 0 2015-01-26 16:07 dm-0
      brw ------- root root 7, 0 2015-01-26 16:07 loop0
      brw ------- root root 7, 1 2015-01-26 16:07 loop1
      brw ------- root root 7, 2 2015-01-26 16:07 loop2
      brw ------- root root 7, 3 2015-01-26 16:07 loop3
      brw ------- root root 7, 4 2015-01-26 16:07 loop4
      brw ------- root root 7, 5 2015-01-26 16:07 loop5
      brw ------- root root 7, 6 2015-01-26 16:07 loop6
      brw ------- root root 7, 7 2015-01-26 16:07 loop7
      brw-rw ---- root system 179, 0 2015-01-26 16:07 mmcblk0
      brw-rw ---- root system 179, 32 2015-01-26 16:07 mmcblk0boot0
      brw-rw ---- root system 179, 64 2015-01-26 16:07 mmcblk0boot1
      brw-rw ---- root system 179, 1 2015-01-26 16:07 mmcblk0p1
      brw ------- root root 179, 10 2015-01-26 16:07 mmcblk0p10
      brw-r ----- root system 179, 11 2015-01-26 16:07 mmcblk0p11
      brw ------- root root 179, 12 2015-01-26 16:07 mmcblk0p12
      brw-rw ---- root system 179, 13 2015-01-26 16:07 mmcblk0p13
      brw ------- root root 179, 14 2015-01-26 16:07 mmcblk0p14
      brw ------- root root 179, 15 2015-01-26 16:07 mmcblk0p15
      brw-rw ---- root system 179, 16 2015-01-26 16:08 mmcblk0p16
      brw ------- root root 179, 17 2015-01-26 16:07 mmcblk0p17
      brw ------- root root 179, 18 2015-01-26 16:07 mmcblk0p18
      brw ------- root root 179, 19 2015-01-26 16:07 mmcblk0p19
      brw-rw ---- root system 179, 2 2015-01-26 16:07 mmcblk0p2
      brw ------- root root 179, 20 2015-01-26 16:07 mmcblk0p20
      brw ------- root root 179, 21 2015-01-26 16:07 mmcblk0p21
      brw-r ----- root system 179, 22 2015-01-26 16:07 mmcblk0p22
      brw ------- root root 179, 23 2015-01-26 16:07 mmcblk0p23
      brw ------- root root 179, 3 2015-01-26 16:07 mmcblk0p3
      brw ------- root root 179, 4 2015-01-26 16:07 mmcblk0p4
      brw-rw ---- root system 179, 5 2015-01-26 16:07 mmcblk0p5
      brw ------- root root 179, 6 2015-01-26 16:07 mmcblk0p6
      brw-r ----- root system 179, 7 2015-01-26 16:07 mmcblk0p7
      brw-r ----- root system 179, 8 2015-01-26 16:07 mmcblk0p8
      brw-r ----- root system 179, 9 2015-01-26 16:07 mmcblk0p9
      brw ------- root root 179, 96 2015-01-26 16:07 mmcblk0rpmb
      drwxr-xr-x root root 2015-01-26 16:07 platform
      drwx ------ root root 2015-01-26 16:07 vold
      brw ------- root root 254, 0 2015-01-26 16:07 zram0

      >>adb shell su -c ls -l / dev / block / platform
      drwxr-xr-x root root 2015-01-26 16:07 mtk-msdc.0

      >>adb shell su -c ls -l / dev / block / vold

      >>adb shell su -c ls -l /dev/block/platform/mtk-msdc.0
      drwxr-xr-x root root 2015-01-26 16:07 11120000.msdc0

      >>adb shell su -c ls -l /dev/block/platform/mtk-msdc.0/11120000.msdc0
      drwxr-xr-x root root 2015-01-26 16:07 by-name
      drwxr-xr-x root root 2015-01-26 16:07 by-num
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0 ->/ dev / block / mmcblk0
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0boot0 ->/ dev / block / mmcblk0boot0
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0boot1 ->/ dev / block / mmcblk0boot1
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p1 ->/ dev / block / mmcblk0p1
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p10 ->/ dev / block / mmcblk0p10
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p11 ->/ dev / block / mmcblk0p11
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p12 ->/ dev / block / mmcblk0p12
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p13 ->/ dev / block / mmcblk0p13
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p14 ->/ dev / block / mmcblk0p14
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p15 ->/ dev / block / mmcblk0p15
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p16 ->/ dev / block / mmcblk0p16
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p17 ->/ dev / block / mmcblk0p17
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p18 ->/ dev / block / mmcblk0p18
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p19 ->/ dev / block / mmcblk0p19
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p2 ->/ dev / block / mmcblk0p2
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p20 ->/ dev / block / mmcblk0p20
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p21 ->/ dev / block / mmcblk0p21
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p22 ->/ dev / block / mmcblk0p22
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p23 ->/ dev / block / mmcblk0p23
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p3 ->/ dev / block / mmcblk0p3
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p4 ->/ dev / block / mmcblk0p4
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p5 ->/ dev / block / mmcblk0p5
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p6 ->/ dev / block / mmcblk0p6
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p7 ->/ dev / block / mmcblk0p7
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p8 ->/ dev / block / mmcblk0p8
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p9 ->/ dev / block / mmcblk0p9
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0rpmb ->/ dev / block / mmcblk0rpmb

      >>adb shell su -c ls -l /dev/block/platform/mtk-msdc.0/11120000.msdc0/by-name
      lrwxrwxrwx root root 2015-01-26 16:07 boot ->/ dev / block / mmcblk0p8
      lrwxrwxrwx root root 2015-01-26 16:07 cache ->/ dev / block / mmcblk0p20
      lrwxrwxrwx root root 2015-01-26 16:07 expdb ->/ dev / block / mmcblk0p14
      lrwxrwxrwx root root 2015-01-26 16:07 flashinfo ->/ dev / block / mmcblk0p23
      lrwxrwxrwx root root 2015-01-26 16:07 frp ->/ dev / block / mmcblk0p16
      lrwxrwxrwx root root 2015-01-26 16:07 keystore ->/ dev / block / mmcblk0p12
      lrwxrwxrwx root root 2015-01-26 16:07 lk ->/ dev / block / mmcblk0p6
      lrwxrwxrwx root root 2015-01-26 16:07 logo ->/ dev / block / mmcblk0p7
      lrwxrwxrwx root root 2015-01-26 16:07 metadata ->/ dev / block / mmcblk0p18
      lrwxrwxrwx root root 2015-01-26 16:07 mobile_info ->/ dev / block / mmcblk0p15
      lrwxrwxrwx root root 2015-01-26 16:07 nvdata ->/ dev / block / mmcblk0p17
      lrwxrwxrwx root root 2015-01-26 16:07 nvram ->/ dev / block / mmcblk0p2
      lrwxrwxrwx root root 2015-01-26 16:07 oemkeystore ->/ dev / block / mmcblk0p10
      lrwxrwxrwx root root 2015-01-26 16:07 otp ->/ dev / block / mmcblk0p22
      lrwxrwxrwx root root 2015-01-26 16:07 para ->/ dev / block / mmcblk0p5
      lrwxrwxrwx root root 2015-01-26 16:07 proinfo ->/ dev / block / mmcblk0p1
      lrwxrwxrwx root root 2015-01-26 16:07 protect1 ->/ dev / block / mmcblk0p3
      lrwxrwxrwx root root 2015-01-26 16:07 protect2 ->/ dev / block / mmcblk0p4
      lrwxrwxrwx root root 2015-01-26 16:07 recovery ->/ dev / block / mmcblk0p9
      lrwxrwxrwx root root 2015-01-26 16:07 seccfg ->/ dev / block / mmcblk0p13
      lrwxrwxrwx root root 2015-01-26 16:07 secro ->/ dev / block / mmcblk0p11
      lrwxrwxrwx root root 2015-01-26 16:07 system ->/ dev / block / mmcblk0p19
      lrwxrwxrwx root root 2015-01-26 16:07 userdata ->/ dev / block / mmcblk0p21

    • 4. The program itself connects information from all three conclusions, checks the sizes of blocks, the names of sections.
    • 5. When copying a partition, it uses exactly the blocks specified in<Scatter file>in the table:<Block:>
    • 6. Copying occurs in stages. I.e:
      • If the partition is smaller than the size of the buffer specified in the program, then the partition is copied entirely to the memory card.
      • Then from the memory card is copied to the PC.
      • And removed from the memory card.

      • If the partition is larger than the size of the buffer specified in the program, then the program calculates the ratio of the buffer and the size of the partition.
        Ie for example, the partition has 156 megabytes, and the buffer is 16 megabytes, then the program will set the buffer to 13 megabytes, respectively 12 blocks of 13 megabytes are obtained (12 * 13 = 156)
      • And it will copy blocks from a partition 12 times in size of 13 megabytes to a memory card.
      • Then on the PC, merge the blocks.
      • And delete blocks from the memory card.

    • 7. Getprop. Displaying this information helps the program know what platform is being used. And apply it.
      >>adb shell getprop
      [ro.sf.hwrotation]: [0]
      [ro.sf.lcd_density]: [320]
      [ro.adb.secure]: [1]
      [ro.apn.presetapn.edit.flag]: [true]
      [ro.com.idea.SP.call]: [false]
      [ro.com.google.gmsversion]: [5.1_r2]
      [ro.com.google.clientidbase]: [android-alcatel]
      [ro.com.google.clientidbase.am]: [android-alcatel]
      [ro.com.google.clientidbase.ms]: [android-alcatel]
      [ro.com.google.clientidbase.yt]: [android-alcatel]
      [ro.com.google.clientidbase.gmm]: [android-alcatel]
      [ro.com.android.dateformat]: [MM-dd-yyyy]
      [ro.com.android.mobiledata]: [false]
      [ro.com.android.dataroaming]: [0]
      [ro.com.android.dataroaming2]: [0]
      [ro.def.mms.autolink.extra]: [0]
      [ro.def.svn.countrycode]: []
      [ro.def.show.sim.change.dialog]: [true]
      [ro.def.show.plmn]: [1]
      [ro.def.russia.num.match.rule]: [0]
      [ro.def.browser]: [0]
      [ro.def.software.svn]: [01001]
      [ro.def.software.version]: [01001]
      [ro.def.phonenumber.Telstra]: [false]
      [ro.def.TelephonyProvider.match]: [0]
      [ro.dtv.support]: [false]
      [ro.frp.pst]: [/dev/block/platform/mtk-msdc.0/by-name/frp]
      [ro.oma.cp.authen_mandatory]: [true]
      [ro.oma.cp.userpin_acceptable]: [true]
      [ro.ssv.enabled]: [false]
      [ro.ssv.mccmncspnlist]: [20416-998 (main), 20416-999]
      [ro.ssv.config_operator]: [none]
      [ro.ssv.diag_sel_config]: [1]
      [ro.sys.usb.mtp.whql.enable]: [0]
      [ro.sys.usb.bicr]: [yes]
      [ro.sys.usb.storage.type]: [mtp, mass_storage]
      [ro.sys.usb.charging.only]: [yes]
      [ro.boot.hardware]: [mt6580]
      [ro.boot.serialno]: [65TW556D99999999 [128m]]
    Method 6 (GPT, Partitions, emmc)
    For this method, the following commands must be executed in ADB:
    • 1. The program copies the first megabyte of the mmcblk0 section, and checks if there is a GPT table in it. If is, then applies them:
      >>adb shell su -c dd if = / dev / block / mmcblk0 of = / sdcard / rom_000 bs = 1048576 count = 1

      >>adb pull / sdcard / rom_000 C: / Rom / rom_000
      [6%] / sdcard / rom_000
      [12%] / sdcard / rom_000
      [18%] / sdcard / rom_000
      [25%] / sdcard / rom_000
      [31%] / sdcard / rom_000
      [37%] / sdcard / rom_000
      [43%] / sdcard / rom_000
      [50%] / sdcard / rom_000
      [56%] / sdcard / rom_000
      [62%] / sdcard / rom_000
      [68%] / sdcard / rom_000
      [75%] / sdcard / rom_000
      [81%] / sdcard / rom_000
      [87%] / sdcard / rom_000
      [93%] / sdcard / rom_000
      [100%] / sdcard / rom_000
      / sdcard / rom_000: 1 file pulled. 4.7 MB / s (1048576 bytes in 0.212s)

      >>adb shell su -c rm / sdcard / rom_000

    • 2. Partitions.
      >>adb shell cat / proc / partitions
      major minor #blocks name
      254 0 499712 zram0
      7 0 21796 loop0
      179 0 7634944 mmcblk0
      179 1 6656 mmcblk0p1
      179 2 5120 mmcblk0p2
      179 3 10240 mmcblk0p3
      179 4 10240 mmcblk0p4
      179 5 512 mmcblk0p5
      179 6,8192 mmcblk0p6
      179 7 8192 mmcblk0p7
      179 8 16384 mmcblk0p8
      179 9 16384 mmcblk0p9
      179 10 8192 mmcblk0p10
      179 11 8192 mmcblk0p11
      179 12,8192 mmcblk0p12
      179 13 917504 mmcblk0p13
      179 14 8192 mmcblk0p14
      179 15 16384 mmcblk0p15
      179 16 8192 mmcblk0p16
      179 17 8192 mmcblk0p17
      179 18 32768 mmcblk0p18
      179 19 32768 mmcblk0p19
      179 20 1286144 mmcblk0p20
      179 21 114688 mmcblk0p21
      179 22 5034496 mmcblk0p22
      179 23 44032 mmcblk0p23
      179 24 16384 mmcblk0p24
      179 96 512 mmcblk0rpmb
      179 64 4096 mmcblk0boot1
      179 32 4096 mmcblk0boot0

    • 3. Emmc.
      >>adb shell cat / proc / emmc
      partno: start_sect nr_sects partition_name
      emmc_p1: 00004000 00003400 "proinfo"
      emmc_p2: 00007400 00002800 "nvram"
      emmc_p3: 00009c00 00005000 "protect1"
      emmc_p4: 0000ec00 00005000 "protect2"
      emmc_p5: 00013c00 00000400 "para"
      emmc_p6: 00014000 00004000 "lk"
      emmc_p7: 00018000 00004000 "logo"
      emmc_p8: 0001c000 00008000 "boot"
      emmc_p9: 00024000 00008000 "recovery"
      emmc_p10: 0002c000 00004000 "oemkeystore"
      emmc_p11: 00030000 00004000 "secro"
      emmc_p12: 00034000 00004000 "keystore"
      emmc_p13: 00038000 001c0000 "custpack"
      emmc_p14: 001f8000 00004000 "seccfg"
      emmc_p15: 001fc000 00008000 "expdb"
      emmc_p16: 00204000 00004000 "mobile_info"
      emmc_p17: 00208000 00004000 "frp"
      emmc_p18: 0020c000 00010000 "nvdata"
      emmc_p19: 0021c000 00010000 "metadata"
      emmc_p20: 0022c000 00274000 "system"
      emmc_p21: 004a0000 00038000 "cache"
      emmc_p22: 004d8000 0099a400 "userdata"
      emmc_p23: 00e72400 00015800 "otp"
      emmc_p24: 00e87c00 00008000 "flashinfo"

    • 4. The program itself connects information from all three conclusions, checks the sizes of blocks, the names of sections.
    • 5. When copying a partition, it uses exactly the blocks specified in<Scatter file>in the table:<Block:>
    • 6. Copying occurs in stages. I.e:
      • If the partition is smaller than the size of the buffer specified in the program, then the partition is copied entirely to the memory card.
      • Then from the memory card is copied to the PC.
      • And removed from the memory card.

      • If the partition is larger than the size of the buffer specified in the program, then the program calculates the ratio of the buffer and the size of the partition.
        Ie for example, the partition has 156 megabytes, and the buffer is 16 megabytes, then the program will set the buffer to 13 megabytes, respectively 12 blocks of 13 megabytes are obtained (12 * 13 = 156)
      • And it will copy blocks from a partition 12 times in size of 13 megabytes to a memory card.
      • Then on the PC, merge the blocks.
      • And delete blocks from the memory card.

    • 7. Getprop. Displaying this information helps the program know what platform is being used. And apply it.
      >>adb shell getprop
      [ro.sf.hwrotation]: [0]
      [ro.sf.lcd_density]: [320]
      [ro.adb.secure]: [1]
      [ro.apn.presetapn.edit.flag]: [true]
      [ro.com.idea.SP.call]: [false]
      [ro.com.google.gmsversion]: [5.1_r2]
      [ro.com.google.clientidbase]: [android-alcatel]
      [ro.com.google.clientidbase.am]: [android-alcatel]
      [ro.com.google.clientidbase.ms]: [android-alcatel]
      [ro.com.google.clientidbase.yt]: [android-alcatel]
      [ro.com.google.clientidbase.gmm]: [android-alcatel]
      [ro.com.android.dateformat]: [MM-dd-yyyy]
      [ro.com.android.mobiledata]: [false]
      [ro.com.android.dataroaming]: [0]
      [ro.com.android.dataroaming2]: [0]
      [ro.def.mms.autolink.extra]: [0]
      [ro.def.svn.countrycode]: []
      [ro.def.show.sim.change.dialog]: [true]
      [ro.def.show.plmn]: [1]
      [ro.def.russia.num.match.rule]: [0]
      [ro.def.browser]: [0]
      [ro.def.software.svn]: [01001]
      [ro.def.software.version]: [01001]
      [ro.def.phonenumber.Telstra]: [false]
      [ro.def.TelephonyProvider.match]: [0]
      [ro.dtv.support]: [false]
      [ro.frp.pst]: [/dev/block/platform/mtk-msdc.0/by-name/frp]
      [ro.oma.cp.authen_mandatory]: [true]
      [ro.oma.cp.userpin_acceptable]: [true]
      [ro.ssv.enabled]: [false]
      [ro.ssv.mccmncspnlist]: [20416-998 (main), 20416-999]
      [ro.ssv.config_operator]: [none]
      [ro.ssv.diag_sel_config]: [1]
      [ro.sys.usb.mtp.whql.enable]: [0]
      [ro.sys.usb.bicr]: [yes]
      [ro.sys.usb.storage.type]: [mtp, mass_storage]
      [ro.sys.usb.charging.only]: [yes]
      [ro.boot.hardware]: [mt6580]
      [ro.boot.serialno]: [65TW556D99999999 [128m]]
    Method 7 (GPT, Partitions, mmcblk0)
    For this method, the following commands must be executed in ADB:
    • 1. The program copies the first megabyte of the mmcblk0 section, and checks if there is a GPT table in it. If is, then applies them:
      >>adb shell su -c dd if = / dev / block / mmcblk0 of = / sdcard / rom_000 bs = 1048576 count = 1

      >>adb pull / sdcard / rom_000 C: / Rom / rom_000
      [6%] / sdcard / rom_000
      [12%] / sdcard / rom_000
      [18%] / sdcard / rom_000
      [25%] / sdcard / rom_000
      [31%] / sdcard / rom_000
      [37%] / sdcard / rom_000
      [43%] / sdcard / rom_000
      [50%] / sdcard / rom_000
      [56%] / sdcard / rom_000
      [62%] / sdcard / rom_000
      [68%] / sdcard / rom_000
      [75%] / sdcard / rom_000
      [81%] / sdcard / rom_000
      [87%] / sdcard / rom_000
      [93%] / sdcard / rom_000
      [100%] / sdcard / rom_000
      / sdcard / rom_000: 1 file pulled. 4.7 MB / s (1048576 bytes in 0.212s)

      >>adb shell su -c rm / sdcard / rom_000

    • 2. Partitions.
      >>adb shell cat / proc / partitions
      major minor #blocks name
      7 0 21796 loop0
      7 1 98304 loop1
      254 0 493824 zram0
      179 0 7634944 mmcblk0
      179 1 6656 mmcblk0p1
      179 2 5120 mmcblk0p2
      179 3 10240 mmcblk0p3
      179 4 10240 mmcblk0p4
      179 5 512 mmcblk0p5
      179 6,8192 mmcblk0p6
      179 7 8192 mmcblk0p7
      179 8 16384 mmcblk0p8
      179 9 16384 mmcblk0p9
      179 10 8192 mmcblk0p10
      179 11 8192 mmcblk0p11
      179 12,8192 mmcblk0p12
      179 13 8192 mmcblk0p13
      179 14 16384 mmcblk0p14
      179 15 8192 mmcblk0p15
      179 16 8192 mmcblk0p16
      179 17 32768 mmcblk0p17
      179 18 32768 mmcblk0p18
      179 19 1761280 mmcblk0p19
      179 20 262144 mmcblk0p20
      179 21 5329408 mmcblk0p21
      179 22 44032 mmcblk0p22
      179 23 16384 mmcblk0p23
      179 96 512 mmcblk0rpmb
      179 64 4096 mmcblk0boot1
      179 32 4096 mmcblk0boot0
      253 0 5329408 dm-0

    • 3. Availability of mmcblk0 and mmcblk0boot0 block:
      >>adb shell ls -l / dev / block / mmcblk0
      / dev / block / mmcblk0: Permission denied (Access denied!)

      >>adb shell su -c ls -l / dev / block / mmcblk0
      brw-rw ---- root system 179, 0 2015-01-26 16:07 mmcblk0

      >>adb shell su -c ls -l / dev / block / mmcblk0boot0
      brw-rw ---- root system 179, 32 2015-01-26 16:07 mmcblk0boot0

    • 4. The program itself connects information from all two pins, copying only takes place on the mmcblk0 block, but from a different starting position and length. The starting position and length is taken from the GPT section.
      Not a very good method, but as an option goes. Sometimes an error occurs on large sections: about the impossibility of copying a block.
    • 5. When copying a partition, it uses exactly the blocks specified in<Scatter file>in the table:<Block:>
    • 6. Copying occurs in stages. I.e:
      • If the partition is smaller than the size of the buffer specified in the program, then the partition is copied entirely to the memory card.
      • Then from the memory card is copied to the PC.
      • And removed from the memory card.

      • If the partition is larger than the size of the buffer specified in the program, then the program calculates the ratio of the buffer and the size of the partition.
        Ie for example, the partition has 156 megabytes, and the buffer is 16 megabytes, then the program will set the buffer to 13 megabytes, respectively 12 blocks of 13 megabytes are obtained (12 * 13 = 156)
      • And it will copy blocks from a partition 12 times in size of 13 megabytes to a memory card.
      • Then on the PC, merge the blocks.
      • And delete blocks from the memory card.

    • 7. Getprop. Displaying this information helps the program know what platform is being used. And apply it.
      >>>>adb shell getprop
      [gsm.version.baseband]: [MOLY.WR8.W1449.MD.WG.MP.V57, 2016/05/20 09:24]
      [gsm.version.baseband1]: [MOLY.WR8.W1449.MD.WG.MP.V57, 2016/05/20 09:24]
      [gsm.version.ril-impl]: [mtk gemini ril 1.0]
      [mediatek.wlan.chip]: [CONSYS_MT6735]
      [mediatek.wlan.ctia]: [0]
      [mediatek.wlan.module.postfix]: [_consys_mt6735]
      [mtk.md1.starttime]: [0s Mon Jan 26 16:07:40 2015]
      [mtk.md1.status]: [ready]
      [mtk.md2.status]: [init_done]
      [[ro.boot.hardware]: [mt6580]
      [ro.boot.mode]: [normal]
      [ro.boot.name]: [android]
      [ro.boot.serialno]: [4TEAD6L7Q86SF6AA]
      [ro.bootimage.build.date]: [Wed May 18 12:26:48 CST 2016]
      [ro.bootimage.build.date.utc]: [1463545608]
      [ro.bootimage.build.fingerprint]: [TCL / 5010X / Pixi4-5: 6.0 / MRA58K / v5E2E-0: user / test-keys]
      [ro.bootloader]: [unknown]
      [ro.bootmode]: [normal]
      [ro.build.characteristics]: [default]
      [ro.build.date]: [Fri May 20 09:22:43 CST 2016]
      [ro.build.date.utc]: [1463707363]
      [ro.build.description]: [full_pixi4_5-user 6.0 MRA58K v5E2E-0 release-keys]
      [ro.build.display.id]: [Marshmallow]
      [ro.build.fingerprint]: [TCL / 5010D / Pixi4-5: 6.0 / MRA58K / v5E2E-0: user / release-keys]
      [ro.build.flavor]: [full_pixi4_5-user]
      [ro.build.host]: [persauto-81]
      [ro.build.id]: [MRA58K]
      [ro.build.product]: [Pixi4-5]
      [ro.build.version.security_patch]: [2016-05-01]
      [ro.mediatek.chip_ver]: [S01]
      [ro.mediatek.gemini_support]: [true]
      [ro.mediatek.platform]: [MT6580]
      [ro.mediatek.project.path]: [device / jrdchz / pixi4_5]
      [ro.mediatek.version.branch]: [alps-mp-m0.mp1]
      [ro.mediatek.version.release]: [alps-mp-m0.mp1-V2.34_jhz6580.we.m_P20]
      [ro.mediatek.version.sdk]: [4]
      [ro.mediatek.wlan.p2p]: [1]
      [ro.mediatek.wlan.wsc]: [1]
      [ro.mount.fs]: [EXT4]
      [ro.mtk.dex2oat_white_list]: [com.facebook: com.google.android.gms:]
      [ro.mtk_shared_sdcard]: [1]
      [ro.mtk_sim_hot_swap]: [1]
      [ro.opengles.version]: [131072]
      [ro.product.board]: []
      [ro.product.brand]: [TCL]
      [ro.product.brand1]: [Orange]
      [ro.product.cpu.abi]: [armeabi-v7a]
      [ro.product.cpu.abi2]: [armeabi]
      [ro.product.cpu.abilist]: [armeabi-v7a, armeabi]
      [ro.product.cpu.abilist32]: [armeabi-v7a, armeabi]
      [ro.product.cpu.abilist64]: []
      [ro.product.device]: [Pixi4-5]
      [ro.product.internal.id]: [Pixi4_5_3G]
      [ro.product.locale.language]: [ru]
      [ro.product.locale.region]: [RU]
      [ro.product.manufacturer]: [TCL]
      [ro.product.model]: [5010D]
      [ro.product.name]: [5010D]
      [ro.product.orangecodename]: [NA58083]
      [ro.product.usb.model]: [Alcatel Pixi 4 (5)]
    Method 8 (GPT, Partitions, Auto)
    For this method, the following commands must be executed in ADB:
    • 1. The program copies the first megabyte of the mmcblk0 section, and checks if there is a GPT table in it. If is, then applies them:
      >>adb shell su -c dd if = / dev / block / mmcblk0 of = / sdcard / rom_000 bs = 1048576 count = 1

      >>adb pull / sdcard / rom_000 C: / Rom / rom_000
      [6%] / sdcard / rom_000
      [12%] / sdcard / rom_000
      [18%] / sdcard / rom_000
      [25%] / sdcard / rom_000
      [31%] / sdcard / rom_000
      [37%] / sdcard / rom_000
      [43%] / sdcard / rom_000
      [50%] / sdcard / rom_000
      [56%] / sdcard / rom_000
      [62%] / sdcard / rom_000
      [68%] / sdcard / rom_000
      [75%] / sdcard / rom_000
      [81%] / sdcard / rom_000
      [87%] / sdcard / rom_000
      [93%] / sdcard / rom_000
      [100%] / sdcard / rom_000
      / sdcard / rom_000: 1 file pulled. 4.7 MB / s (1048576 bytes in 0.212s)

      >>adb shell su -c rm / sdcard / rom_000

    • 2. Partitions.
      >>adb shell cat / proc / partitions
      major minor #blocks name
      7 0 21796 loop0
      7 1 98304 loop1
      254 0 493824 zram0
      179 0 7634944 mmcblk0
      179 1 6656 mmcblk0p1
      179 2 5120 mmcblk0p2
      179 3 10240 mmcblk0p3
      179 4 10240 mmcblk0p4
      179 5 512 mmcblk0p5
      179 6,8192 mmcblk0p6
      179 7 8192 mmcblk0p7
      179 8 16384 mmcblk0p8
      179 9 16384 mmcblk0p9
      179 10 8192 mmcblk0p10
      179 11 8192 mmcblk0p11
      179 12,8192 mmcblk0p12
      179 13 8192 mmcblk0p13
      179 14 16384 mmcblk0p14
      179 15 8192 mmcblk0p15
      179 16 8192 mmcblk0p16
      179 17 32768 mmcblk0p17
      179 18 32768 mmcblk0p18
      179 19 1761280 mmcblk0p19
      179 20 262144 mmcblk0p20
      179 21 5329408 mmcblk0p21
      179 22 44032 mmcblk0p22
      179 23 16384 mmcblk0p23
      179 96 512 mmcblk0rpmb
      179 64 4096 mmcblk0boot1
      179 32 4096 mmcblk0boot0
      253 0 5329408 dm-0

    • 3. The program itself connects information from all two conclusions, checks the block sizes, their name.
    • 4. When copying a partition, it uses exactly the blocks specified in<Scatter file>in the table:<Block:>
    • 5. Copying occurs in stages. I.e:
      • If the partition is smaller than the size of the buffer specified in the program, then the partition is copied entirely to the memory card.
      • Then from the memory card is copied to the PC.
      • And removed from the memory card.

      • If the partition is larger than the size of the buffer specified in the program, then the program calculates the ratio of the buffer and the size of the partition.
        Ie for example, the partition has 156 megabytes, and the buffer is 16 megabytes, then the program will set the buffer to 13 megabytes, respectively 12 blocks of 13 megabytes are obtained (12 * 13 = 156)
      • And it will copy blocks from a partition 12 times in size of 13 megabytes to a memory card.
      • Then on the PC, merge the blocks.
      • And delete blocks from the memory card.

    • 6. Getprop. Displaying this information helps the program know what platform is being used. And apply it.
      >>>>adb shell getprop
      [gsm.version.baseband]: [MOLY.WR8.W1449.MD.WG.MP.V57, 2016/05/20 09:24]
      [gsm.version.baseband1]: [MOLY.WR8.W1449.MD.WG.MP.V57, 2016/05/20 09:24]
      [gsm.version.ril-impl]: [mtk gemini ril 1.0]
      [mediatek.wlan.chip]: [CONSYS_MT6735]
      [mediatek.wlan.ctia]: [0]
      [mediatek.wlan.module.postfix]: [_consys_mt6735]
      [mtk.md1.starttime]: [0s Mon Jan 26 16:07:40 2015]
      [mtk.md1.status]: [ready]
      [mtk.md2.status]: [init_done]
      [[ro.boot.hardware]: [mt6580]
      [ro.boot.mode]: [normal]
      [ro.boot.name]: [android]
      [ro.boot.serialno]: [4TEAD6L7Q86SF6AA]
      [ro.bootimage.build.date]: [Wed May 18 12:26:48 CST 2016]
      [ro.bootimage.build.date.utc]: [1463545608]
      [ro.bootimage.build.fingerprint]: [TCL / 5010X / Pixi4-5: 6.0 / MRA58K / v5E2E-0: user / test-keys]
      [ro.bootloader]: [unknown]
      [ro.bootmode]: [normal]
      [ro.build.characteristics]: [default]
      [ro.build.date]: [Fri May 20 09:22:43 CST 2016]
      [ro.build.date.utc]: [1463707363]
      [ro.build.description]: [full_pixi4_5-user 6.0 MRA58K v5E2E-0 release-keys]
      [ro.build.display.id]: [Marshmallow]
      [ro.build.fingerprint]: [TCL / 5010D / Pixi4-5: 6.0 / MRA58K / v5E2E-0: user / release-keys]
      [ro.build.flavor]: [full_pixi4_5-user]
      [ro.build.host]: [persauto-81]
      [ro.build.id]: [MRA58K]
      [ro.build.product]: [Pixi4-5]
      [ro.build.version.security_patch]: [2016-05-01]
      [ro.mediatek.chip_ver]: [S01]
      [ro.mediatek.gemini_support]: [true]
      [ro.mediatek.platform]: [MT6580]
      [ro.mediatek.project.path]: [device / jrdchz / pixi4_5]
      [ro.mediatek.version.branch]: [alps-mp-m0.mp1]
      [ro.mediatek.version.release]: [alps-mp-m0.mp1-V2.34_jhz6580.we.m_P20]
      [ro.mediatek.version.sdk]: [4]
      [ro.mediatek.wlan.p2p]: [1]
      [ro.mediatek.wlan.wsc]: [1]
      [ro.mount.fs]: [EXT4]
      [ro.mtk.dex2oat_white_list]: [com.facebook: com.google.android.gms:]
      [ro.mtk_shared_sdcard]: [1]
      [ro.mtk_sim_hot_swap]: [1]
      [ro.opengles.version]: [131072]
      [ro.product.board]: []
      [ro.product.brand]: [TCL]
      [ro.product.brand1]: [Orange]
      [ro.product.cpu.abi]: [armeabi-v7a]
      [ro.product.cpu.abi2]: [armeabi]
      [ro.product.cpu.abilist]: [armeabi-v7a, armeabi]
      [ro.product.cpu.abilist32]: [armeabi-v7a, armeabi]
      [ro.product.cpu.abilist64]: []
      [ro.product.device]: [Pixi4-5]
      [ro.product.internal.id]: [Pixi4_5_3G]
      [ro.product.locale.language]: [ru]
      [ro.product.locale.region]: [RU]
      [ro.product.manufacturer]: [TCL]
      [ro.product.model]: [5010D]
      [ro.product.name]: [5010D]
      [ro.product.orangecodename]: [NA58083]
      [ro.product.usb.model]: [Alcatel Pixi 4 (5)]
    Method 9 (GPT, Partitions, by-name)
    For this method, the following commands must be executed in ADB:
    • 1. The program copies the first megabyte of the mmcblk0 section, and checks if there is a GPT table in it. If is, then applies them:
      >>adb shell su -c dd if = / dev / block / mmcblk0 of = / sdcard / rom_000 bs = 1048576 count = 1

      >>adb pull / sdcard / rom_000 C: / Rom / rom_000
      [6%] / sdcard / rom_000
      [12%] / sdcard / rom_000
      [18%] / sdcard / rom_000
      [25%] / sdcard / rom_000
      [31%] / sdcard / rom_000
      [37%] / sdcard / rom_000
      [43%] / sdcard / rom_000
      [50%] / sdcard / rom_000
      [56%] / sdcard / rom_000
      [62%] / sdcard / rom_000
      [68%] / sdcard / rom_000
      [75%] / sdcard / rom_000
      [81%] / sdcard / rom_000
      [87%] / sdcard / rom_000
      [93%] / sdcard / rom_000
      [100%] / sdcard / rom_000
      / sdcard / rom_000: 1 file pulled. 4.7 MB / s (1048576 bytes in 0.212s)

      >>adb shell su -c rm / sdcard / rom_000

    • 2. Partitions.
      >>adb shell cat / proc / partitions
      major minor #blocks name
      7 0 21796 loop0
      7 1 98304 loop1
      254 0 493824 zram0
      179 0 7634944 mmcblk0
      179 1 6656 mmcblk0p1
      179 2 5120 mmcblk0p2
      179 3 10240 mmcblk0p3
      179 4 10240 mmcblk0p4
      179 5 512 mmcblk0p5
      179 6,8192 mmcblk0p6
      179 7 8192 mmcblk0p7
      179 8 16384 mmcblk0p8
      179 9 16384 mmcblk0p9
      179 10 8192 mmcblk0p10
      179 11 8192 mmcblk0p11
      179 12,8192 mmcblk0p12
      179 13 8192 mmcblk0p13
      179 14 16384 mmcblk0p14
      179 15 8192 mmcblk0p15
      179 16 8192 mmcblk0p16
      179 17 32768 mmcblk0p17
      179 18 32768 mmcblk0p18
      179 19 1761280 mmcblk0p19
      179 20 262144 mmcblk0p20
      179 21 5329408 mmcblk0p21
      179 22 44032 mmcblk0p22
      179 23 16384 mmcblk0p23
      179 96 512 mmcblk0rpmb
      179 64 4096 mmcblk0boot1
      179 32 4096 mmcblk0boot0
      253 0 5329408 dm-0

    • 3. The program is looking for a folder (directory) named<by-name>after folder (directory)</ dev / block>. It has an approximate conclusion:
      >>adb shell ls -l / dev / block
      / dev / block: Permission denied

      >>adb shell su -c ls -l / dev / block
      brw ------- root root 253, 0 2015-01-26 16:07 dm-0
      brw ------- root root 7, 0 2015-01-26 16:07 loop0
      brw ------- root root 7, 1 2015-01-26 16:07 loop1
      brw ------- root root 7, 2 2015-01-26 16:07 loop2
      brw ------- root root 7, 3 2015-01-26 16:07 loop3
      brw ------- root root 7, 4 2015-01-26 16:07 loop4
      brw ------- root root 7, 5 2015-01-26 16:07 loop5
      brw ------- root root 7, 6 2015-01-26 16:07 loop6
      brw ------- root root 7, 7 2015-01-26 16:07 loop7
      brw-rw ---- root system 179, 0 2015-01-26 16:07 mmcblk0
      brw-rw ---- root system 179, 32 2015-01-26 16:07 mmcblk0boot0
      brw-rw ---- root system 179, 64 2015-01-26 16:07 mmcblk0boot1
      brw-rw ---- root system 179, 1 2015-01-26 16:07 mmcblk0p1
      brw ------- root root 179, 10 2015-01-26 16:07 mmcblk0p10
      brw-r ----- root system 179, 11 2015-01-26 16:07 mmcblk0p11
      brw ------- root root 179, 12 2015-01-26 16:07 mmcblk0p12
      brw-rw ---- root system 179, 13 2015-01-26 16:07 mmcblk0p13
      brw ------- root root 179, 14 2015-01-26 16:07 mmcblk0p14
      brw ------- root root 179, 15 2015-01-26 16:07 mmcblk0p15
      brw-rw ---- root system 179, 16 2015-01-26 16:08 mmcblk0p16
      brw ------- root root 179, 17 2015-01-26 16:07 mmcblk0p17
      brw ------- root root 179, 18 2015-01-26 16:07 mmcblk0p18
      brw ------- root root 179, 19 2015-01-26 16:07 mmcblk0p19
      brw-rw ---- root system 179, 2 2015-01-26 16:07 mmcblk0p2
      brw ------- root root 179, 20 2015-01-26 16:07 mmcblk0p20
      brw ------- root root 179, 21 2015-01-26 16:07 mmcblk0p21
      brw-r ----- root system 179, 22 2015-01-26 16:07 mmcblk0p22
      brw ------- root root 179, 23 2015-01-26 16:07 mmcblk0p23
      brw ------- root root 179, 3 2015-01-26 16:07 mmcblk0p3
      brw ------- root root 179, 4 2015-01-26 16:07 mmcblk0p4
      brw-rw ---- root system 179, 5 2015-01-26 16:07 mmcblk0p5
      brw ------- root root 179, 6 2015-01-26 16:07 mmcblk0p6
      brw-r ----- root system 179, 7 2015-01-26 16:07 mmcblk0p7
      brw-r ----- root system 179, 8 2015-01-26 16:07 mmcblk0p8
      brw-r ----- root system 179, 9 2015-01-26 16:07 mmcblk0p9
      brw ------- root root 179, 96 2015-01-26 16:07 mmcblk0rpmb
      drwxr-xr-x root root 2015-01-26 16:07 platform
      drwx ------ root root 2015-01-26 16:07 vold
      brw ------- root root 254, 0 2015-01-26 16:07 zram0

      >>adb shell su -c ls -l / dev / block / platform
      drwxr-xr-x root root 2015-01-26 16:07 mtk-msdc.0

      >>adb shell su -c ls -l / dev / block / vold

      >>adb shell su -c ls -l /dev/block/platform/mtk-msdc.0
      drwxr-xr-x root root 2015-01-26 16:07 11120000.msdc0

      >>adb shell su -c ls -l /dev/block/platform/mtk-msdc.0/11120000.msdc0
      drwxr-xr-x root root 2015-01-26 16:07 by-name
      drwxr-xr-x root root 2015-01-26 16:07 by-num
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0 ->/ dev / block / mmcblk0
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0boot0 ->/ dev / block / mmcblk0boot0
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0boot1 ->/ dev / block / mmcblk0boot1
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p1 ->/ dev / block / mmcblk0p1
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p10 ->/ dev / block / mmcblk0p10
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p11 ->/ dev / block / mmcblk0p11
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p12 ->/ dev / block / mmcblk0p12
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p13 ->/ dev / block / mmcblk0p13
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p14 ->/ dev / block / mmcblk0p14
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p15 ->/ dev / block / mmcblk0p15
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p16 ->/ dev / block / mmcblk0p16
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p17 ->/ dev / block / mmcblk0p17
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p18 ->/ dev / block / mmcblk0p18
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p19 ->/ dev / block / mmcblk0p19
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p2 ->/ dev / block / mmcblk0p2
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p20 ->/ dev / block / mmcblk0p20
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p21 ->/ dev / block / mmcblk0p21
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p22 ->/ dev / block / mmcblk0p22
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p23 ->/ dev / block / mmcblk0p23
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p3 ->/ dev / block / mmcblk0p3
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p4 ->/ dev / block / mmcblk0p4
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p5 ->/ dev / block / mmcblk0p5
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p6 ->/ dev / block / mmcblk0p6
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p7 ->/ dev / block / mmcblk0p7
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p8 ->/ dev / block / mmcblk0p8
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0p9 ->/ dev / block / mmcblk0p9
      lrwxrwxrwx root root 2015-01-26 16:07 mmcblk0rpmb ->/ dev / block / mmcblk0rpmb

      >>adb shell su -c ls -l /dev/block/platform/mtk-msdc.0/11120000.msdc0/by-name
      lrwxrwxrwx root root 2015-01-26 16:07 boot ->/ dev / block / mmcblk0p8
      lrwxrwxrwx root root 2015-01-26 16:07 cache ->/ dev / block / mmcblk0p20
      lrwxrwxrwx root root 2015-01-26 16:07 expdb ->/ dev / block / mmcblk0p14
      lrwxrwxrwx root root 2015-01-26 16:07 flashinfo ->/ dev / block / mmcblk0p23
      lrwxrwxrwx root root 2015-01-26 16:07 frp ->/ dev / block / mmcblk0p16
      lrwxrwxrwx root root 2015-01-26 16:07 keystore ->/ dev / block / mmcblk0p12
      lrwxrwxrwx root root 2015-01-26 16:07 lk ->/ dev / block / mmcblk0p6
      lrwxrwxrwx root root 2015-01-26 16:07 logo ->/ dev / block / mmcblk0p7
      lrwxrwxrwx root root 2015-01-26 16:07 metadata ->/ dev / block / mmcblk0p18
      lrwxrwxrwx root root 2015-01-26 16:07 mobile_info ->/ dev / block / mmcblk0p15
      lrwxrwxrwx root root 2015-01-26 16:07 nvdata ->/ dev / block / mmcblk0p17
      lrwxrwxrwx root root 2015-01-26 16:07 nvram ->/ dev / block / mmcblk0p2
      lrwxrwxrwx root root 2015-01-26 16:07 oemkeystore ->/ dev / block / mmcblk0p10
      lrwxrwxrwx root root 2015-01-26 16:07 otp ->/ dev / block / mmcblk0p22
      lrwxrwxrwx root root 2015-01-26 16:07 para ->/ dev / block / mmcblk0p5
      lrwxrwxrwx root root 2015-01-26 16:07 proinfo ->/ dev / block / mmcblk0p1
      lrwxrwxrwx root root 2015-01-26 16:07 protect1 ->/ dev / block / mmcblk0p3
      lrwxrwxrwx root root 2015-01-26 16:07 protect2 ->/ dev / block / mmcblk0p4
      lrwxrwxrwx root root 2015-01-26 16:07 recovery ->/ dev / block / mmcblk0p9
      lrwxrwxrwx root root 2015-01-26 16:07 seccfg ->/ dev / block / mmcblk0p13
      lrwxrwxrwx root root 2015-01-26 16:07 secro ->/ dev / block / mmcblk0p11
      lrwxrwxrwx root root 2015-01-26 16:07 system ->/ dev / block / mmcblk0p19
      lrwxrwxrwx root root 2015-01-26 16:07 userdata ->/ dev / block / mmcblk0p21

    • 4. The program itself connects information from all three conclusions, checks the block sizes, their name.
    • 5. When copying a partition, it uses exactly the blocks specified in<Scatter file>in the table:<Block:>
    • 6. Copying occurs in stages. I.e:
      • If the partition is smaller than the size of the buffer specified in the program, then the partition is copied entirely to the memory card.
      • Then from the memory card is copied to the PC.
      • And removed from the memory card.

      • If the partition is larger than the size of the buffer specified in the program, then the program calculates the ratio of the buffer and the size of the partition.
        Ie for example, the partition has 156 megabytes, and the buffer is 16 megabytes, then the program will set the buffer to 13 megabytes, respectively 12 blocks of 13 megabytes are obtained (12 * 13 = 156)
      • And it will copy blocks from a partition 12 times in size of 13 megabytes to a memory card.
      • Then on the PC, merge the blocks.
      • And delete blocks from the memory card.

    • 7. Getprop. Displaying this information helps the program know what platform is being used. And apply it.
      >>>>adb shell getprop
      [gsm.version.baseband]: [MOLY.WR8.W1449.MD.WG.MP.V57, 2016/05/20 09:24]
      [gsm.version.baseband1]: [MOLY.WR8.W1449.MD.WG.MP.V57, 2016/05/20 09:24]
      [gsm.version.ril-impl]: [mtk gemini ril 1.0]
      [mediatek.wlan.chip]: [CONSYS_MT6735]
      [mediatek.wlan.ctia]: [0]
      [mediatek.wlan.module.postfix]: [_consys_mt6735]
      [mtk.md1.starttime]: [0s Mon Jan 26 16:07:40 2015]
      [mtk.md1.status]: [ready]
      [mtk.md2.status]: [init_done]
      [[ro.boot.hardware]: [mt6580]
      [ro.boot.mode]: [normal]
      [ro.boot.name]: [android]
      [ro.boot.serialno]: [4TEAD6L7Q86SF6AA]
      [ro.bootimage.build.date]: [Wed May 18 12:26:48 CST 2016]
      [ro.bootimage.build.date.utc]: [1463545608]
      [ro.bootimage.build.fingerprint]: [TCL / 5010X / Pixi4-5: 6.0 / MRA58K / v5E2E-0: user / test-keys]
      [ro.bootloader]: [unknown]
      [ro.bootmode]: [normal]
      [ro.build.characteristics]: [default]
      [ro.build.date]: [Fri May 20 09:22:43 CST 2016]
      [ro.build.date.utc]: [1463707363]
      [ro.build.description]: [full_pixi4_5-user 6.0 MRA58K v5E2E-0 release-keys]
      [ro.build.display.id]: [Marshmallow]
      [ro.build.fingerprint]: [TCL / 5010D / Pixi4-5: 6.0 / MRA58K / v5E2E-0: user / release-keys]
      [ro.build.flavor]: [full_pixi4_5-user]
      [ro.build.host]: [persauto-81]
      [ro.build.id]: [MRA58K]
      [ro.build.product]: [Pixi4-5]
      [ro.build.version.security_patch]: [2016-05-01]
      [ro.mediatek.chip_ver]: [S01]
      [ro.mediatek.gemini_support]: [true]
      [ro.mediatek.platform]: [MT6580]
      [ro.mediatek.project.path]: [device / jrdchz / pixi4_5]
      [ro.mediatek.version.branch]: [alps-mp-m0.mp1]
      [ro.mediatek.version.release]: [alps-mp-m0.mp1-V2.34_jhz6580.we.m_P20]
      [ro.mediatek.version.sdk]: [4]
      [ro.mediatek.wlan.p2p]: [1]
      [ro.mediatek.wlan.wsc]: [1]
      [ro.mount.fs]: [EXT4]
      [ro.mtk.dex2oat_white_list]: [com.facebook: com.google.android.gms:]
      [ro.mtk_shared_sdcard]: [1]
      [ro.mtk_sim_hot_swap]: [1]
      [ro.opengles.version]: [131072]
      [ro.product.board]: []
      [ro.product.brand]: [TCL]
      [ro.product.brand1]: [Orange]
      [ro.product.cpu.abi]: [armeabi-v7a]
      [ro.product.cpu.abi2]: [armeabi]
      [ro.product.cpu.abilist]: [armeabi-v7a, armeabi]
      [ro.product.cpu.abilist32]: [armeabi-v7a, armeabi]
      [ro.product.cpu.abilist64]: []
      [ro.product.device]: [Pixi4-5]
      [ro.product.internal.id]: [Pixi4_5_3G]
      [ro.product.locale.language]: [ru]
      [ro.product.locale.region]: [RU]
      [ro.product.manufacturer]: [TCL]
      [ro.product.model]: [5010D]
      [ro.product.name]: [5010D]
      [ro.product.orangecodename]: [NA58083]
      [ro.product.usb.model]: [Alcatel Pixi 4 (5)]
That's all for now. I hope the program will help you. Methods and instructions will be updated!
Video instructions
Errors noted
2.30 version
  • AT<Autopilot>After scanning, searching for partitions, the function of determining read partitions does not work correctly, but can be corrected manually, that is, if the section was read inclusively by system (along with<system>), the auto selection will not enable the checkbox on it, that is, the auto selection does not include the last read section.
    Solution: After scanning in<Autopilot>when the program offers to enter<Scatter file>and remove unnecessary checkboxes on sections, you must go in and check the box on the last section you want, which was read byROMfile. If you have a fullROM, that's okay, everything will be fine.

  • Sometimes wrong pulls outPreloader, nothing terrible will happen, because the SP Flash Tool will tell you about it that Preloader is not Preloader.
    The error is fixed, in the new version everything will be fine.
    Solution: Take advantage of this: SP Flash Tool - Flash driver for MTK smartphones. (Post RealYoti # 62066982)

  • The program crashes if in sectionPGPTmore than 50 positions of section names. The error is fixed, in the new version everything will be fine.
    Solution: There are no solutions yet, as this can onlyWwr_mtk(Pull out information from PGPT), there may of course be solutions, it is necessary to search in themes or programs for re-marking the memory of devices.

  • When the program createsScatter fileof the values ​​found, it runs the section names according to some template file<Template.ini>which indicates which sections are sewn and which are not. And if in this template file there is no necessary section, then it is automatically set as<Update>, ie to flash. In the New version it will be the other way round, all the positions of the sections will be set as non-firmware, and then they will only follow the pattern.
Past versions

Addition to the scatter files created:
If you use the created scatter file for the device firmware, then you need to reduce the length of the UserData section in the scatter file itself to 3 GB (0xC0000000), subject:WwR MTK (Post vvaaavv # 70864827)

About crypto section UserData

Merge the firmware from one device and flash this firmware to another device

Hello. Please test. Maybe there will be some errors on different versions of the platform. All did not have time to modify.
Corrections and improvements continue almost every day.

To contact the topic, formulate your questions and wishes more clearly, competently, in detail .. thus there will be fewer questions.
If something does not work in the program, or it works but not correctly, please prepare your Backup in advance for consideration. To do this, pack it into the archive (preferably * .7z), place it somewhere on the cloud storage (Yandex disk, Cloud Mail.Ru, Google drive) and give the link to the author of the program inQMS. For your data you can not worry, nothing, never went to the people. Or you can cut the UserData section and everything after it (For your confidence).
And remember .. each backup sent improves the performance of the program!


Thank you very muchUm4 for fixing hats!

Post has been editedvvaaavv - 02.03.19, 20:26
Reason for editing: Supplement
Camous
Message#2
30.04.17, 11:45
a guest
*
[offline]

Group: Users
Messages 2
Check in: 16.06.14

Reputation:-  0  +

cool how to check accomplish;)
ilabuu03
Message#3
01.05.17, 02:53
Visitor
**
[offline]

Group: Active users
Messages 18
Check in: 26.02.16
Alcatel POP C5 OT-5036D

Reputation:-  0  +

I correctly understood that this prog can, like Victoria, not use (disable) unnecessary NAND memory sections?
vvaaavv
Message#4
01.05.17, 11:56
Old resident
*******
[offline]

Group: Friendssavagemessiahzine.com
Messages 742
Check in: 17.02.12

Reputation:-  401  +

Ilabuu03 @ 01.05.17, 02:53*
I correctly understood that this prog can, like Victoria, not use (disable) unnecessary NAND memory sections?


I do not understand you..
Victoria is a program for working with hard drives.
Write in a personal ..

Post has been editedvvaaavv - 02.05.17, 01:01


--------------------
DeveloperWwR MTK
I work from 8.00 - 20.00 Moscow time. At work, there is not much time to answer in drugs and in topics. Answers to all questions only after 21.00
Bodya-kolibass
Message#5
06.05.17, 23:54
The local
*********
[online]

Group: Friendssavagemessiahzine.com
Messages 3275
Check in: 03.01.14
Xiaomi Redmi 5 3/32

Reputation:-  1478  +

* vvaaavv
Thanks for the work. I tried to pull out the preloader on my device (in the signature) - the utility coped without questions.


--------------------
My humble works on 4
A man cannot know everything and possess the full truth, but he can strive for it ...
Petr7666
Message#6
08.05.17, 04:55
Novice
***
[online]

Group: Active users
Messages 33
Check in: 27.02.14
Nomu S30

Reputation:-  13  +

Great program. Thank you very much.
vvaaavv
Message#7
08.05.17, 15:07
Old resident
*******
[offline]

Group: Friendssavagemessiahzine.com
Messages 742
Check in: 17.02.12

Reputation:-  401  +

Hello. Happy May 9th.
Corrected the program.

Version 2.15 Fixed minor bugs. (I incorrectly found the last FF at the ends and the fix for the MT6589 scatter file of the old sample)
In general, you need to check for the platform MT6589. (I will find I will test)


--------------------
DeveloperWwR MTK
I work from 8.00 - 20.00 Moscow time. At work, there is not much time to answer in drugs and in topics. Answers to all questions only after 21.00
Lomaster_Serg
Message#8
09.05.17, 20:01
Lomaster
*********
[offline]

Group: Friendssavagemessiahzine.com
Messages 6306
Check in: 11.01.14
Blackview BV8000 Pro

Reputation:-  1166  +

* vvaaavv
Good day!
accidentally stumbled upon your theme with this program, a very handy thing ..! for which you special thanks in the form of a plus!
when I was looking for something like this, but without success ... with the advent of new mtc processors, sometimes you have to manually do the scatter and merge partitions ..
To be honest, I learned to do all these tricks by hand for a long time, but the application will be very popular, I have no doubt about it .. and you should throw a link to this topic for a long time (although it may already be there!?)
... well, and taking advantage of the opportunity, I immediately had a question for you .., having experienced a prog for the sake of sports interest
I did not quite understand one thing:
Let's say I have a 64bit platform with a stone mtk6755 .. then in due time I merged a ROM that is lying on my computer ..
after some time (with the advent of experience) I found out that the preloader section is in a different region than the other sections .. accordingly in my merged rum it simply shouldn't be !?
but when you try to cut the ROM into pieces on the scatter, your program successfully creates a preloader image from rom-a that merges from the EMMC_USER region
and how does it turn out? .. the preloader is in the EMMC_BOOT1_BOOT2 region
I think the essence of my question you understand!?

Post has been editedserg2327 - 10.05.17, 05:52
vvaaavv
Message#9
09.05.17, 20:49
Old resident
*******
[offline]

Group: Friendssavagemessiahzine.com
Messages 742
Check in: 17.02.12

Reputation:-  401  +

serg2327 @ 05/09/17, 20:01*
Preloader is in the EMMC_BOOT1_BOOT2 region


Yes, it is EMMC_BOOT1_BOOT2
Just in all phones on MT67xx, if there is a PGPT section, and to do a scatter on it, the program writes two sections by itself: 1) Preloader - EMMC_BOOT1 and 2) PGPT - EMMC_USER
I noticed that wherever there is a PGPT section, it goes at the very beginning of EMMC_USER, and in the PGPT itself there is no information about the preloader and the PGPT itself.

serg2327 @ 05/09/17, 20:01*
but when you try to cut the rum into pieces on the scatter, your program successfully creates an image of a preloader from rum that merges with the EMMC_USER region


And therefore it may be wrong here, the program simply does not know about these nuances, there in the scatter the first two sections start with 0x0 (this is a preloader and pgpt). Only PGPT will be true ....

Generally understood, I’ll add it for MT67xx with PGPT partitions so that I don’t choose a partition for cutting EMMC_BOOT1_BOOT2.

Post has been editedvvaaavv - 09.05.17, 21:05


--------------------
DeveloperWwR MTK
I work from 8.00 - 20.00 Moscow time. At work, there is not much time to answer in drugs and in topics. Answers to all questions only after 21.00
Lomaster_Serg
Message#10
09.05.17, 21:02
Lomaster
*********
[offline]

Group: Friendssavagemessiahzine.com
Messages 6306
Check in: 11.01.14
Blackview BV8000 Pro

Reputation:-  1166  +

* vvaaavv

I understand all this .. I just mean all this to the fact that inexperienced users can chop their rum and God forbid they will take advantage of a fake preloader that creates a program from rum, where in fact there is no preloader.

Of course, if you use the "preloader" tab in the program, slip the desired ROM with the preloader, then the program correctly pulls it out of the rum ..
In any case, I think that this constructor is a masterpiece that will very quickly become popular, because there are simply no analogues!

Post has been editedserg2327 - 09.05.17, 21:13
Bodya-kolibass
Message#11
09.05.17, 21:04
The local
*********
[online]

Group: Friendssavagemessiahzine.com
Messages 3275
Check in: 03.01.14
Xiaomi Redmi 5 3/32

Reputation:-  1478  +

precisely for MT67xx
Not only for these stones ... For example, the 6580 also has GPT markup. It may be worthwhile to do some checking of the content of the beginning of the ROM and already on the basis of what data is contained, for example, in the first megabyte, indicate to the user what he will get at the output and what the ROM is (if this is technically possible, of course).
UPD. Are you the preloader that way? Accordingly, if the utility sees the contents of the corresponding sgpt - notify the user about it. Well, something like this...

Post has been editedBodya-kolibass - 09.05.17, 21:07


--------------------
My humble works on 4
A man cannot know everything and possess the full truth, but he can strive for it ...
vvaaavv
Message#12
09.05.17, 21:14
Old resident
*******
[offline]

Group: Friendssavagemessiahzine.com
Messages 742
Check in: 17.02.12

Reputation:-  401  +

Bodya-Kolibass @ 05/09/17, 21:04*
Accordingly, if the utility sees the contents of the corresponding sgpt - notify the user about it. Well, something like this...


A good idea. I will implement.


--------------------
DeveloperWwR MTK
I work from 8.00 - 20.00 Moscow time. At work, there is not much time to answer in drugs and in topics. Answers to all questions only after 21.00
vvaaavv
Message#13
09.05.17, 21:24
Old resident
*******
[offline]

Group: Friendssavagemessiahzine.com
Messages 742
Check in: 17.02.12

Reputation:-  401  +

serg2327 @ 05/09/17, 21:02*
inexperienced users can cut their rum and, God forbid, take advantage of a fake preloader that creates a prog from rum


The preloader is searched for certain signatures, if they are not there, then the preloader can not be pulled out of the Rom file ..
Well, here I also understood everything .. I finish it, for users, if there is no preloader in Rom, then it is not necessary to split it ...

And in general, to cut the section with the preloader is also not correct ... After all, you also need to pull it out. Ok, I know how to do it right.

Post has been editedvvaaavv - 09.05.17, 21:28


--------------------
DeveloperWwR MTK
I work from 8.00 - 20.00 Moscow time. At work, there is not much time to answer in drugs and in topics. Answers to all questions only after 21.00
vvaaavv
Message#14
10.05.17, 01:40
Old resident
*******
[offline]

Group: Friendssavagemessiahzine.com
Messages 742
Check in: 17.02.12

Reputation:-  401  +

Everything is implemented.
Now in version 2.20 Automatically when cutting a ROM (if the checkbox is on the Preloader) Not just cuts the partition, but pulls out the preloader, if it is there of course.
If the preloader is not there, and the checkbox is checked, then this section will be ignored.


--------------------
DeveloperWwR MTK
I work from 8.00 - 20.00 Moscow time. At work, there is not much time to answer in drugs and in topics. Answers to all questions only after 21.00
82ronin
Message#15
10.05.17, 11:43
Quo
*****
[offline]

Group: Friendssavagemessiahzine.com
Messages 326
Check in: 24.12.12
Xiaomi Redmi 4X 3/32

Reputation:-  30  +

* vvaaavv
button not available: blush:
Attached Image

M
Rules section and FAQ on creating topics
- when adding screenshots to a message, remove the images in the spoilerHow to clean the image under the spoiler.


Post has been editedvadeus - 10.05.17, 12:46


--------------------
"My business to offer, your refuse" (c)
Sedy
Message#16
10.05.17, 11:58
Guru
*********
[online]

Group: Friendssavagemessiahzine.com
Messages 2279
Check in: 06.09.06
Samsung Galaxy Note 4 SM-N910F

Reputation:-  345  +

* 82ronin, A piece is not clear what you have chosen and want to get a firmware from it


--------------------
Samsung Note 4 N910T3
Xiaomi routers: 3P, 3G, 3C
82ronin
Message#17
10.05.17, 11:59
Quo
*****
[offline]

Group: Friendssavagemessiahzine.com
Messages 326
Check in: 24.12.12
Xiaomi Redmi 4X 3/32

Reputation:-  30  +

* Sedy
cut ROM, I showed ROM;)
or should the skater be the first to show?

Post has been edited82ronin - 10.05.17, 12:03


--------------------
"My business to offer, your refuse" (c)
Sedy
Message#18
10.05.17, 12:30
Guru
*********
[online]

Group: Friendssavagemessiahzine.com
Messages 2279
Check in: 06.09.06
Samsung Galaxy Note 4 SM-N910F

Reputation:-  345  +

* 82roninAre you sure that this is rum and its size does not bother you? And it is not known from what starting address it is read.


--------------------
Samsung Note 4 N910T3
Xiaomi routers: 3P, 3G, 3C
82ronin
Message#19
10.05.17, 12:40
Quo
*****
[offline]

Group: Friendssavagemessiahzine.com
Messages 326
Check in: 24.12.12
Xiaomi Redmi 4X 3/32

Reputation:-  30  +

* Sedy
Do not bother, there is no cash and user.
there are already cut regions.
P.S.
I'm just testing a program, I want to know what she can do ...

Post has been edited82ronin - 10.05.17, 12:41


--------------------
"My business to offer, your refuse" (c)
vvaaavv
Message#20
10.05.17, 14:56
Old resident
*******
[offline]

Group: Friendssavagemessiahzine.com
Messages 742
Check in: 17.02.12

Reputation:-  401  +

82ronin @ 05/10/17, 12:40*
I'm just testing a program, I want to know what she can do ...


A little instruction.
Scatter file from the air can not be done yet (whether the magic is over, or something else :))
Therefore, if we are talking only about the ROM file, without the corresponding file scatter file, which you do not have.
Go to the tab<Search for sections>, there we poke a button<To start searching>and we hope (you can cross over and pray) that there are sections like PMT or PGPT, only they accurately indicate which regions are in the ROM file, and no way else .. There you can also see which sections can be located by addresses, BUT IT APPROXIMATELY, AND NOT ACCURATE, AND THEREFORE, IT IS NOT IMPOSSIBLE TO CREATE SCATTER FILE !!!
A scatter file is created only from PMT or PGPT partitions, or use the scatter that goes to your firmware, if you are sure of it, If you are not sure, compare the scatter file and the result of the search for partitions by start and length ...


--------------------
DeveloperWwR MTK
I work from 8.00 - 20.00 Moscow time. At work, there is not much time to answer in drugs and in topics. Answers to all questions only after 21.00
82ronin
Message#21
10.05.17, 17:22
Quo
*****
[offline]

Group: Friendssavagemessiahzine.com
Messages 326
Check in: 24.12.12
Xiaomi Redmi 4X 3/32

Reputation:-  30  +

* vvaaavvThank you, I understood that.

Post has been edited82ronin - 10.05.17, 17:24


--------------------
"My business to offer, your refuse" (c)

58 pagesV  1 2 3 4 5 6 > » 


 mobile version    Now: 04/30/19, 20:12