[X]Assistant

[vvaaavv]

WwR MTK download

Version: 2.50 Beta

Last update of the program in the header:01.05.2019

!!!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.
  
• View EXT4 sections in the ROM file itself, extract files (files only) from EXT4 to ROM.
  
• Creating empty sections EXT4, for a given length, the ability to convert into a sparse image.
  
• Create empty sections or files filled with zeros or random numbers.
  
• When you open the ROM file, instantly view the partition table GPT, PMT, MBR.
  
• 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.50 Beta:
WwR_2.50_Rus.zip(46.75 MB)
WwR_2.50_Eng.zip(46.75 MB)

Attention! Until May 9, the topic header and instructions in it will change due to the release of the new version of the program

Screenshots:

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 !!!
  
  
• Version 2.50
  
  • Changed the program interface.
    
  • Automatic selection of the second file. If ROM_1 is selected (EMMC_USER), ROM_0 (EMMC_BOOT_1 or ready Preloader) is selected.
    
  • Added new tabs and features.
    
  • When you open a ROM file, the program instantly recognizes the markup (GPT, PMT, MBR), and displays its structure in a special table.
    
  • Autopilot changed the algorithm of almost all functions.
    
  • Autopilot modified platform definition.
    
  • View sections EXT4 in the ROM file. Extract files to EXT4.
    
  • Creating a clean partition EXT4, with conversion to Spasre and without.
    
  • Create empty files of any size, filled with zeros or random numbers.
    
  • Creating a scatter file of 1 megabyte GPT sections on MTK.
    
  • View build.prop for a second.
    
  • Check the ROM and scatter file.
    
  • In the mode of operation by ADB, you can connect more than one device.
    
  • In the ADB mode, the device automatically connects or reconnects, waits, adds.
    
  • Improved work on cutting ROM, the speed of reading and writing now depends on the hard disk and motherboard.
    
  • 
    
  • Implemented a lot of changes and additions !!!
  
  

Instructions. General principles of work for version 2.50

Select a file in the program (EMMC_USER)

When you press a button<Select a file>. You must select a ROM file read from the device dump.
The program itself determines what type of ROM it is and displays the corresponding message. Example:

It also displays the parameters of the GPT partition, its full volume, the start of the GPT markup, and the backup copy - SGPT.
More immediately shows markup for GPT, PMT, MBR. in the partition table.

Automatic detection of markup type when selecting the EMMC_USER ROM file

When selecting a ROM file (EMMC_USER), the program immediately determines the type of markup, this is GPT or MBR + EBR. If there is a PMT partition table in the first 26 megabytes, it will show the PMT markup.
Here on examples it looks like this:

GPT markup

MBR markup

PMT markup

If nothing appears in the table, and the program has opened a tab<Search for sections>it is worth thinking here - is everything OK with the ROM file ?!

File selection in the program (EMMC_BOOT_1)

When a file is selected, it is EMMC_BOOT_1, in which the Preloader is sewn up. The program scans this file and if this ROM is actually a file in which there is a Preloader, the program selects this file with the second file and shows it below. This opens the tab<Preloader>and happening<Preloader Analysis>, then you can pull Preloader.

Example

If the file is a finished Preloader, the program will also open it with the second file, and open the tab<Preloader>.

Preloader example

The program will warn you that you have already chosen Preloader. And a button<Pull out Preloader and save as ..>will not be active (since there is no sense in pulling out what has already been pulled out).

EMMC Parser function, when analyzing the Preloader

This is necessary for those who change memory chips that have failed. Because in Preloader there is information about the compatibility of memory chips with the device's hardware.
Here is an example:

EMMC Parser Example

In this example, the Preloader has 9 compatible memory chips, which are listed in the table. The CID of the chip and the CID name are displayed in any case, but their parameters are contained in the emmc.txt file in the program folder. Due to the fact that there are a lot of microcircuits, and new ones appear every day, and the manufacturers do not give out the parameters of the microcircuit by the CID number anywhere, so this file is filled in manually.

Automatic selection of the second file

When you select the ROM_1 file (EMMC_USER), the program itself selects EMMC_BOOT_1 (usually ROM_0) or the finished Preloader. Provided that the file is in the same directory.
When a ROM_0 file is selected (EMMC_BOOT_1), the program itself selects EMMC_USER (usually ROM_1). Provided that the file is in the same directory.
If for some reason the program did not select the second file (or the first one), select the file yourself, manually, just press again<File selection>and select the desired file.

Autopilot

1. Creating an empty scatter file:

Empty scatter file - there is no information about the sections in it, only the header of the scatter file, which indicates the type of platform and type of memory in the device and the first section with the Preloader. This is all necessary for reading a dump from the device’s memory.
This empty scatter file is needed only for reading a memory dump from the device, flashing with such a scatter file - It is impossible !!!
The type of device platform can be determined through ADB, for this you do not need root rights, or google. If you specify incorrectly, the SP Flash Tool will give you an error when connecting the device to the PC in read mode.
The memory type is used only two types: EMMC and NAND. In the case of EMMC, the block is selected at 0x20000. In the case of NAND, the block can be anythingbut be sure to choose the right one.You can use the scatter file from the stock firmware and see what is there. If there is no such scatter file, then you can read the firmware with a block size of 0x20000, then select this dump and run<Start scan>in the tab<Search for sections>. The program itself determines the dimension of the block. Then, in the empty scatter file, set the correct dimension of the block and read the dump again.

Example in the picture:

Only this option I turned out to be a worker!

2. Read the firmware from the device:

Here it is written as:WwR MTK (Post vvaaavv # 60035994)

3. Launch autopilot:

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

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:
  Figure 201, if the memory in the NAND device:
  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:
  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:
  2.5. If successful, a window with a green circle and a check mark should come out (Figure 204).
  
  Figure 204:

  
  
  
• 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:
  
  *** 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:
  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:
  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:
  
  If you have a platform MT6757 / MT6797 and instead<Ram test>coming out<DRAM Flip Test>(Figure 207-3).
  
  Figure 207-3:
  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:
  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:
  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:

  

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:
  
  
• 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:
  Figure 201, if the memory in the NAND device:
  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:
  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:
  2.4. If successful, a window with a green circle and a check mark should come out (Figure 204).
  
  Figure 204:

  
  
  
• 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:
  
  *** 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:
  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:
  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:
  
  If you have a platform MT6757 / MT6797 and instead<Ram test>coming out<DRAM Flip Test>(Figure 207-3).
  
  Figure 207-3:
  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:
  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:
  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:

  

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:
• 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:
• 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:
• 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:
• 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:
  
  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:
    
    
  • This is an example<ROM>file read with<Spare>opened in the HEX editor (Figure 221)
    
    Figure 221:
    
    *** 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:
  
  Now we have a list of all sections in a way understandable for perception (Figure 211).
  
  Figure 211:
  
  
• 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:
  
  
• 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
  
  
• 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:
  Figure 201, if the memory in the NAND device:
  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:
  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:
  4.4. If successful, a window with a green circle and a check mark should come out (Figure 204).
  
  Figure 204:

  
  
  
• 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:
  5.4. Next, click<Ok>and<Read back>. And we completely connect the phone to the computer. (Figure 208-1).
  
  Figure 208-1:
  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:

  
  
  
• 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:
  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
  
  
• 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

• Video 10. WwR_MTK 2.50. General principles of the program. Part 1
  
• Video 11. WwR_MTK 2.50. General principles of the program. Part 2
  
• Video 12. WwR_MTK 2.50. General principles of the program. Part 3
  
• Video 13. WwR_MTK 2.50. General principles of the program. Part 4
  
  
• Video 1. Phone Platform Type:MT65xx , but not MT6580
  
• Video 2. Phone platform type:MT65xx , but not MT6580
  
• Video 3. Phone Platform Type:MT65xx , but not MT6580
  
• Video 4
  
• Video 5. Phone Platform Type:MT67xx and MT6580
  
• Video 6. Phone Platform Type:MT67xx and MT6580
  
• Video 7. Phone Platform Type:MT67xx and MT6580
  
• Video 8. Memory Type:NAND . File system UBIFS . Present Spare
  
• Video 9. Memory Type:NAND . File system UBIFS . Present Spare

Laiki to put, thereby helping the project.

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

• WwR_2.40_Rus.rar(32.69 MB)
  
• WwR_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)
  
  
• WwR_MTK_v2.30.rar(20.44 MB)
  
  
• WwR_MTK_v2.20.rar(14.3 MB)
  
  
• WwR_MTK_v2.15.rar(14.3 MB)
  
  
• WwR_MTK_v2.10.rar(14.3 MB)
  
  
• WwR_MTK_v2.0b.rar(14.3 MB)
  
  
• WwR_MTK_v1.9b.rar(14.28 MB)
  
  
• WwR_MTK_v1.8b.rar(14.27 MB)
  
  
• WWR_MTK_v1.5b.rar(14.11 MB)
  
  
• WWR_MTK_v1.4.5b.rar(14.11 MB)
  
  
• WWR_MTK_v1.4b.rar(14.11 MB)
  
  
• WWR_MTK_v1.3b.rar(14.65 MB)
  

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.05.19, 09:45

Reason for editing: Changing the topic header and instructions in connection with the release of the new version of the program

[kirichen]

liverpool_fan91,
Spec Device
And flash did not try to do a dump, backup?
and then cut into sections by this program .......
Chinese copy of Samsung Galaxy S8 + (MT6580) - Discussion

Post has been editedkirichen - 16.03.19, 01:20

[vvaaavv]

liverpool_fan91 @ 03/15/19, 10:59 PM

When connected to a PC, the phone is seen as a carrier as much as 22 MB, of which 17 are free. Where are these 16GB hidden?

Yes, that's right .. I saw a lot of these .. there is a memory chip worth 512 MB (0x20000000)
And on such devices, the file system is usually UBI_FS, and the memory there is not EMMC, but NAND.
Therefore:
1) It is better to merge all 512 MB (0x20000000) via SPFT, empty scatter file
2) Reading mode is required only<Read Page Only>
3) You must correctly guess the size<block_size:>, it happens 0x20000, 0x40000 - in your case. (I saw such that 8 Gigov NAND, there this block is greater than 0x200000, 0x600000)
4) Usually, their PMT table is outside UserData at the very end.

Pay attention here:WwR MTK (Post vvaaavv # 60035994)

[liverpool_fan91]

vvaaavv
All it is, memory nand, 512mb.
1. I drain through the flasher, with an empty tablecloth, I indicate the end of the dump from the programs in the tab adb.
2. I put a check on Read Page Only
3. The size of the blocks tried and he and the other

[vvaaavv]

liverpool_fan91 @ 03/16/19, 09:13

I specify the end of the dump from the program, in the tab adb.

Specify 0x20000000 in SPFT
And then the dimension of the blocks can be viewed as:

Then re-use the SPFT and an empty scatter file, where the correct dimension of the blocks will be specified .. This is very important.
In my experiments, only those phones were included and in which the dimension of the blocks was correct.

[liverpool_fan91]

kirichen
I flash and make a backup, and that instruction doesn’t suit me a bit as well as my memory is nand and not emms

vvaaavv
I specified 0x20000000, indicated the correct dimension of the blocks, then made a backup again. Now, according to the same instruction (If the device turns on, there is no root right), point 6, option 1 no longer has an error, splits the firmware, but there is a warning

The image contains MBR markup, a PMT (1vTP) section was found containing all sections of the firmware and their positions. The length of all sections combined has the size: 0x1F1C0000. The file you selected has the size: 0x20000000. The full size of the firmware can not be determined. To do this, you must use the SP Flash Tool (Tab<Memory Test>, remove all the checkboxes except<Ram test>, click on<Start>. After the operation is completed, information about the type of memory will appear, and its full capacity.)
Most likely you have a full or almost complete firmware. Since the file size exceeds the size of all sections combined. Now you can open the tab<Scatter file>and uncheck sections that you don't need!
Now you can open the tab<Scatter file>and see which sections are not read (there are no flags on them). You can also uncheck the boxes on sections that you do not need!
Preloader name: preloader_hexing71_cwet_lca.bin, Processor type: MT6571, Memory: NAND.

If the second option, then the same error "as a result of the check, it turned out that the positions of the section starts in the ROM file do not match the information from the device itself"

Post has been editedliverpool_fan91 - 17.03.19, 22:10

[andru666]

I have at one opens the video windows in a quality and with an incomprehensible conversation (muffled) ate audible and understandable

[vvaaavv]

[email protected], 19:54

I have at one opens the video windows in a quality and with an incomprehensible conversation (muffled) ate audible and understandable

Buy a normal microphone - rewrite all the videos.

[andru666]

vvaaavvbut then I thought my dynamics tyutyu.

[Lomaster_Serg]

Forgive me in advance if I repeat and this problem has already been discussed .. but today, cutting rum from one new body (mtk6771) is not my first smart on this chip and didn’t have previous problems ..
So, the essence of the problem: in the "autopilot" mode at the stage of analysis of markup and other things, the program asks to slip the image of the region boot1, after which the application is cursed that there is no processor information in the lk block and something went wrong :

This is certainly not fatal, but for people who are not experienced it turns out to be “plugged” and wondering about what to do next.
I just went to the scatter tab and cut it into blocks and created a scatter, specifying the processor manually ...
Shl
If the program did not find something, you need to add the ability to continue the procedure of creating the firmware but with the indication of the processor manually IMHO

Post has been editedLomaster_Serg - 21.03.19, 14:02

[vvaaavv]

Lomaster_Serg @ 03/21/19, 1:55

This is certainly not fatal, but for people who are not experienced it turns out to be “plugged” and wondering about what to do next.

Soon a new version will be released .. everything has already been fixed in it .. and for the future too, so that there would be no such rake ..
Now I’m finishing the program, the last stages .. there is a check .. So far all the dumps (2 Terabytes), and I’ll not really try out 11 different devices ..

[otido2010]

vvaaavv
I often have donors if something needs to be checked write

[X3non]

vvaaavv

I will also help to check if you need help with testing the MT6580 :)
sorry for bad russian, i use google translate

Post has been editedX3non - 23.03.19, 23:41

[jane-jack]

vvaaavvif need help. Always ready to help.

[Chatter]

Prompt noob. Disassembled in auto dump mode, in the scatter there is no [PRO_INFO] section at the end of the file with the following configuration data:
Version = vKA100207
Hardware = 0x300x340x790x310x370x300x710x300x300x300x300x300x300x30-0x300x610x340x380x68
HardwareEx = 0x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x300x30
HwDetail = @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ - @ -

I substitute my proinfo with the firmware, but the touch and the inverted screen do not work.
Can I pull this info out of the dump with WwR MTK?

[X3non]

Chatter
Download the firmware dump in WwR, allow it to search all partitions.
click the scattered file tab
put a tick in front of PROINFO
then cut off the rum. wwr will add proinfo to the list when cutting

[Lomaster_Serg]

Chatter @ 03.26.19, 11:50

I substitute my proinfo with the firmware, but the touch and the inverted screen do not work.
Can I pull this info out of the dump with WwR MTK?

But I wonder, not really that infa in this block is so important ??
I noticed that on some platforms a factory number was registered there and something else, but I thought for some reason that the infa in this block is generated when the smartphone starts for the first time (from some other / other important blocks! ??

Simply, many users like to format smartphones (by inexperience) as a result, after restoring the firmware, there are some disadvantages
But what has the touch and screen?
The touch in the core and the position of the screen in buil.prop is written either in the bootloader itself ..

I think you just flashed the wrong firmware into your body (not that revision) IMHO

Post has been editedLomaster_Serg - 26.03.19, 14:31

[Chatter]

X3non @ 03.26.19, 10:51

will add proinfo to the list when cutting

Actually there is no problem with proinfo, it is cut. The problem is in creating a scatter file, there is no text with the hardware configuration. As far as I understand, this data can be pulled from proinfo.

Posted on 03/26/2019 2:36 PM:

Lomaster_Serg @ 03.26.19, 11:28

But I wonder, not really that infa in this block is so important ??

Jlinksz K960 - Discussion

Lomaster_Serg @ 03.26.19, 11:28

I think you just flashed the wrong firmware into your body (not that revision) IMHO

Yes, there was a native firmware and there would be no questions (

[Lomaster_Serg]

Chatter
I meet such shamanistic rituals for the first time ... but there, if we continue to read, it turns out that every place and place is mirrored ...
And secondly, depending on the platform and the firmware itself, the proinfo block can be anywhere ..
On new mtk, it is generally in the middle of the list ... and contains information in the form of an incomprehensible encoding, the usual Notepad ++ can not read it
Helio P60 example:proinfo.rar(1.72 KB)
what are the "zeros" solid ..
Yes, and in general, I looked through live dumps from 6580/6739/6755/6757/6763/6771
everywhere in proinfo "zero", some at the beginning of the serial number is registered ...

Shl
at the very end of the scatter (the penultimate one as a rule) there is a block called flashinfo
what can there is in it !? I never merged it

Post has been editedLomaster_Serg - 26.03.19, 15:19

[Chatter]

Lomaster_Serg @ 03.26.19, 11:50

for the first time I meet such shaman rites

Perhaps, but it is proinfo editing that gives results.
Jlinksz K960 - Discussion (Post by motordig # 61170883)

[vvaaavv]

Chatter @ 03.26.19, 14:32

The problem is in creating a scatter file, there is no text with the hardware configuration. As far as I understand, this data can be pulled from proinfo.

This is true, do so:

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, Mail.Ru Cloud, Google disk) and give the link to the author of the program in QMS. 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!

It's in a hat