CN113742283B - NANDFLASH non-file system bad block management method based on LINUX operation system - Google Patents
NANDFLASH non-file system bad block management method based on LINUX operation system Download PDFInfo
- Publication number
- CN113742283B CN113742283B CN202110819797.8A CN202110819797A CN113742283B CN 113742283 B CN113742283 B CN 113742283B CN 202110819797 A CN202110819797 A CN 202110819797A CN 113742283 B CN113742283 B CN 113742283B
- Authority
- CN
- China
- Prior art keywords
- block
- bad
- nandflash
- new
- bad blocks
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000007726 management method Methods 0.000 title claims abstract description 16
- 238000007493 shaping process Methods 0.000 claims description 44
- 101150110532 CFDP1 gene Proteins 0.000 claims description 9
- 238000000034 method Methods 0.000 claims description 8
- 230000004048 modification Effects 0.000 abstract description 5
- 238000012986 modification Methods 0.000 abstract description 5
- 238000012217 deletion Methods 0.000 description 2
- 230000037430 deletion Effects 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/10—File systems; File servers
- G06F16/11—File system administration, e.g. details of archiving or snapshots
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
- G06F3/0601—Interfaces specially adapted for storage systems
- G06F3/0602—Interfaces specially adapted for storage systems specifically adapted to achieve a particular effect
- G06F3/0614—Improving the reliability of storage systems
- G06F3/0619—Improving the reliability of storage systems in relation to data integrity, e.g. data losses, bit errors
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
- G06F3/0601—Interfaces specially adapted for storage systems
- G06F3/0628—Interfaces specially adapted for storage systems making use of a particular technique
- G06F3/0638—Organizing or formatting or addressing of data
- G06F3/064—Management of blocks
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
- G06F3/0601—Interfaces specially adapted for storage systems
- G06F3/0668—Interfaces specially adapted for storage systems adopting a particular infrastructure
- G06F3/0671—In-line storage system
- G06F3/0673—Single storage device
- G06F3/0679—Non-volatile semiconductor memory device, e.g. flash memory, one time programmable memory [OTP]
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Human Computer Interaction (AREA)
- Data Mining & Analysis (AREA)
- Databases & Information Systems (AREA)
- Computer Security & Cryptography (AREA)
- Techniques For Improving Reliability Of Storages (AREA)
- Read Only Memory (AREA)
Abstract
The invention provides a bad block management method of NANDFLASH non-file system based on LINUX operation system, comprising the following steps: under LINUX operation system, the bad blocks are automatically skipped when the blocks are read, written and erased by modifying the NANDFLASH driver. The invention uses the modifiable characteristic of the kernel source code of the LINUX operating system to carry out specific modification on the NANDFLASH driver, so that the NANDFLASH driver has the function of automatically skipping bad blocks. Therefore, the application program is free from sense under the condition of no file system, and the space of NANDFLASH is continuously read, written and erased without worrying about the problem of bad blocks.
Description
Technical Field
The invention relates to the technical field of security management of file systems, in particular to a NANDFLASH bad block management method of a file system based on a LINUX operating system.
Background
Because of NANDFLASH's technology, the producer can only guarantee that block 0 is not a bad block when the chip leaves the factory. It is possible for the other blocks to be bad blocks. Therefore, bad blocks need to be managed when NANDFLASH is read and written, and bad blocks of read and write operations are avoided. Bad blocks are managed in the linux operating system through the file systems of JFFS2, YAFFS2, flashFx and the like which are specially aimed at NANDFLASH. After the file system is provided, a user only needs to call an interface of the file system to perform operations such as reading, writing, erasing and the like on NANDFLASH, and the management problem of specific blocks and bad blocks of the operations is not required to be concerned. However, if the data (i.e., file) stored on the NANDFLASH is to be deleted after the file system is present, the deletion interface of the file system is called to delete only the information of the data (i.e., file) from the file allocation table of the file system. While the data on the block actually storing the data is not deleted. The data on the block can be read out by corresponding programming tools or programs. Data leakage is easy to occur in the special field, and safety is lacking. The application layer may operate the NANDFLASH via its device node (e.g.:/dev/mtd 0) if the corresponding file system is not used. But cannot judge the bad blocks and skip the corresponding bad blocks. If the bad block is operated on, the data will not be stored correctly.
Disclosure of Invention
The invention aims to provide a NANDFLASH non-file system bad block management method based on LINUX operation system, which solves the problems that NANDFLASH managed by using a file system cannot be really deleted during deletion, data leakage is easy to cause, safety is lack, and bad blocks cannot be avoided without using the file system to operate NANDFLASH.
The invention provides a bad block management method of NANDFLASH non-file system based on LINUX operation system, comprising: under LINUX operation system, the bad blocks are automatically skipped when the blocks are read, written and erased by modifying the NANDFLASH driver.
Further, the bad block management method includes the following steps:
s1, obtaining a bad block of NANDFLASH;
s2, designing an algorithm for automatically skipping bad blocks according to the acquired bad blocks;
s3, modifying a NANDFLASH driver based on a designed algorithm for automatically skipping bad blocks;
s4, recompiling the kernel of the LINUX operating system after modifying the NANDFLASH driver.
Further, the method for obtaining the bad block of the NANDFLASH in the step S1 includes the following sub-steps:
s11, defining a shaping array with the length of 32 and a shaping variable in a kernel file nand_bbt.c file; the shaping array is used for storing bad block IDs of NANDFLASH; the shaping variables are used for recording the total number of bad blocks;
s12, storing bad block IDs scanned by the create_bbt () function into a shaping array, and recording the total number of bad blocks by using shaping variables;
s13, the total number of the shaping array and the bad blocks is derived by utilizing the kernel EXPORT_SYMBOL macro.
Further, bad block IDs stored in the shaping array are arranged from small to large.
Further, the method for automatically skipping the bad blocks according to the obtained bad block design in the step S2 includes the following sub-steps:
s21, judging whether the input block ID is smaller than the minimum bad block ID in the shaping array:
if yes, indicating that the input block ID has no bad block in front, and returning the current block ID without skipping the bad block, namely the operated block is the current block;
if not, executing step S22;
s22, judging whether the total number of the input block IDs and the bad blocks is larger than the largest bad block ID in the shaping array:
if yes, returning the block_id+nandflash_bbt_cnt as a new block ID; wherein, block_id represents the input block ID, nandflash_bbt_cnt represents the total number of bad blocks;
if not, then step S23 is performed;
s23, judging whether the input ID is in the shaping array:
if yes, acquiring the number of bad blocks smaller than the input block ID as bcnt, and the number of continuous bad blocks from the input ID as ccnt1, wherein the new block ID is new_id=block_id+bcnt+ccnt1;
if not, the new block ID is new_id=block_id+bcnt, and then step S24 is performed;
s24, judging whether the new block ID obtained in the step S23 is in the shaping array:
if yes, acquiring the number ccnt2 of consecutive bad blocks in the shaping array, wherein new_id=new_id+ccnt2+1;
repeating the step S24 until the new block ID is not in the shaping array, and executing the step S25;
s25, obtaining the number of bad blocks smaller than the new block ID as m and obtaining the number of bad blocks smaller than the input block ID as n; if m > n, then new_id=block_id+m, step S26 is performed;
s26, repeating the steps S24-S25 to generate a final new block ID;
s27, returning to the final new block ID generated in the step S26.
Further, the method for modifying the driver of the NANDFLASH based on the designed algorithm for automatically skipping bad blocks in the step S3 includes the following sub-steps:
for read and write operations, two functions of a spin_read_page () and a spin_program_page () in a kernel file nand_spin.c file are modified, and an incoming page ID is converted into a corresponding block ID; then, calling an algorithm designed in the step S2 for automatically skipping bad blocks to acquire new block IDs, and converting the acquired new block IDs into new page IDs; and finally, using the new page ID to operate NANDFLASH.
For the erasing operation, the spin_erase_block () function directly calls the algorithm designed in step S2 to automatically skip bad blocks to obtain new IDs, and then performs block erasing on the new IDs.
In summary, due to the adoption of the technical scheme, the beneficial effects of the invention are as follows:
the invention uses the modifiable characteristic of the kernel source code of the LINUX operating system to carry out specific modification on the NANDFLASH driver, so that the NANDFLASH driver has the function of automatically skipping bad blocks. Therefore, the application program is free from sense under the condition of no file system, and the space of NANDFLASH is continuously read, written and erased without worrying about the problem of bad blocks.
Drawings
In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the following description will briefly describe the drawings in the embodiments, it being understood that the following drawings only illustrate some embodiments of the present invention and should not be considered as limiting the scope, and that other related drawings may be obtained according to these drawings without inventive effort for a person skilled in the art.
Fig. 1 is a flowchart of a bad block management method of a NANDFLASH no-file system based on a LINUX operating system according to an embodiment of the present invention.
Detailed Description
For the purpose of making the objects, technical solutions and advantages of the embodiments of the present invention more apparent, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention, and it is apparent that the described embodiments are some embodiments of the present invention, but not all embodiments of the present invention. The components of the embodiments of the present invention generally described and illustrated in the figures herein may be arranged and designed in a wide variety of different configurations.
Thus, the following detailed description of the embodiments of the invention, as presented in the figures, is not intended to limit the scope of the invention, as claimed, but is merely representative of selected embodiments of the invention. All other embodiments, which can be made by those skilled in the art based on the embodiments of the invention without making any inventive effort, are intended to be within the scope of the invention.
Examples
The embodiment provides a bad block management method of a NANDFLASH file-free system based on a LINUX operation system, which comprises the following steps: under LINUX operation system, the bad blocks are automatically skipped when the blocks are read, written and erased by modifying the NANDFLASH driver. Therefore, the application program can perform operations such as continuous space reading, writing, erasing and the like under the condition that the NANDFLASH does not use a file system, and further the data security is improved.
As shown in fig. 1, the bad block management method specifically includes the following steps:
s1, obtaining bad blocks of NANDFLASH:
s11, defining a shaping array with the length of 32 and a shaping variable in a kernel file nand_bbt.c file; the shaping array is used for storing bad block IDs of NANDFLASH; the shaping variables are used for recording the total number of bad blocks; the following is shown:
int nandflash_bbt [32] = {0}; nandflash_bbt is a defined shaping array;
int nandflash_bbt_cnt=0; nandflash_bbt_cnt is a defined shaping variable.
S12, storing bad block IDs scanned by the create_bbt () function into a shaping array (nandflash_bbt), and recording the total number of bad blocks by using a shaping variable (nandflash_bbt_cnt); and the bad block IDs stored in the shaping array are arranged from small to large.
S13, the total number of the shaping array and the bad blocks is derived by utilizing the kernel EXPORT_SYMBOL macro. The following is shown:
EXPORT_SYMBOL(nandflash_bbt)；
EXPORT_SYMBOL(nandflash_bbt_cnt)。
s2, designing an algorithm for automatically skipping bad blocks according to the acquired bad blocks:
s21, judging whether the input block ID (expressed as block_id) is smaller than the minimum bad block ID in the shaping array:
if yes, indicating that the input block ID has no bad block in front, and returning the current block ID without skipping the bad block, namely the operated block is the current block;
if not, executing step S22;
s22, judging whether the total number of the input block ID+bad blocks (namely block_id+nandflash_bbt_cnt) is larger than the largest bad block ID in the shaping array:
if yes, returning the block_id+nandflash_bbt_cnt as a new block ID;
if not, then step S23 is performed;
s23, judging whether the input ID is in the shaping array:
if yes, acquiring the number of bad blocks smaller than the input block ID as bcnt, and the number of continuous bad blocks from the input ID as ccnt1, wherein the new block ID is new_id=block_id+bcnt+ccnt1; it should be noted that: (1) If the input block is a bad block, the number of bad blocks smaller than the ID of the block contains the block; (2) The number of consecutive bad blocks refers to the number of bad blocks consecutive to the bad block ID, for example, bad block IDs 3, 6, 7, 8, 12. Then the consecutive bad blocks with the following bad block ID of 6 are 7 and 8, i.e. the number of consecutive bad blocks is 2);
if not, the new block ID is new_id=block_id+bcnt, and then step S24 is performed;
s24, judging whether the new block ID obtained in the step S23 is in the shaping array:
if yes, acquiring the number ccnt2 of consecutive bad blocks in the shaping array, wherein new_id=new_id+ccnt2+1;
repeating the step S24 until the new block ID is not in the shaping array, and executing the step S25;
s25, obtaining the number of bad blocks smaller than the new block ID as m and obtaining the number of bad blocks smaller than the input block ID as n; if m > n, then new_id=block_id+m, step S26 is performed;
s26, repeating the steps S24-S25 to generate a final new block ID;
s27, returning to the final new block ID generated in the step S26.
S3, modifying a NANDFLASH driver based on a designed algorithm for automatically skipping bad blocks:
for read and write operations, two functions of a spin_read_page () and a spin_program_page () in a kernel file nand_spin.c file are modified, and an incoming page ID is converted into a corresponding block ID; then, calling an algorithm designed in the step S2 for automatically skipping bad blocks to acquire new block IDs, and converting the acquired new block IDs into new page IDs; and finally, using the new page ID to operate NANDFLASH.
For the erasing operation, the spin_erase_block () function directly calls the algorithm designed in step S2 to automatically skip bad blocks to obtain new IDs, and then performs block erasing on the new IDs.
S4, recompiling the kernel of the LINUX operating system after modifying the NANDFLASH driver.
The invention realizes the bad block management method of NANDFLASH without file system based on LINUX operation system, which uses the modifiable characteristic of LINUX operation system kernel source code to make special modification to NANDFLASH driver program to make it have the function of automatic skipping bad block. Therefore, the application program is free from sense under the condition of no file system, and the space of NANDFLASH is continuously read, written and erased without worrying about the problem of bad blocks.
The above description is only of the preferred embodiments of the present invention and is not intended to limit the present invention, but various modifications and variations can be made to the present invention by those skilled in the art. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present invention should be included in the protection scope of the present invention.
Claims (3)
1. A bad block management method of NANDFLASH non-file system based on LINUX operation system is characterized in that the bad block management method comprises: under LINUX operation system, the bad block is automatically skipped when the block is read, written and erased by modifying the NANDFLASH driver;
the bad block management method comprises the following steps:
s1, obtaining a bad block of NANDFLASH;
s2, designing an algorithm for automatically skipping bad blocks according to the acquired bad blocks;
s3, modifying a NANDFLASH driver based on a designed algorithm for automatically skipping bad blocks;
s4, recompiling the kernel of the LINUX operating system after modifying the NANDFLASH driver;
the method for automatically skipping the algorithm of the bad blocks according to the acquired bad block design in the step S2 comprises the following sub-steps:
s21, judging whether the input block ID is smaller than the minimum bad block ID in the shaping array:
if yes, indicating that the input block ID has no bad block in front, and returning the current block ID without skipping the bad block, namely the operated block is the current block;
if not, executing step S22;
s22, judging whether the total number of the input block IDs and the bad blocks is larger than the largest bad block ID in the shaping array:
if yes, returning the block_id+nandflash_bbt_cnt as a new block ID; wherein, block_id represents the input block ID, nandflash_bbt_cnt represents the total number of bad blocks;
if not, then step S23 is performed;
s23, judging whether the input ID is in the shaping array:
if yes, acquiring the number of bad blocks smaller than the input block ID as bcnt, and the number of continuous bad blocks from the input ID as ccnt1, wherein the new block ID is new_id=block_id+bcnt+ccnt1;
if not, the new block ID is new_id=block_id+bcnt, and then step S24 is performed;
s24, judging whether the new block ID obtained in the step S23 is in the shaping array:
if yes, acquiring the number ccnt2 of consecutive bad blocks in the shaping array, wherein new_id=new_id+ccnt2+1;
repeating the step S24 until the new block ID is not in the shaping array, and executing the step S25;
s25, obtaining the number of bad blocks smaller than the new block ID as m and obtaining the number of bad blocks smaller than the input block ID as n; if m > n, then new_id=block_id+m, step S26 is performed;
s26, repeating the steps S24-S25 to generate a final new block ID;
s27, returning to the final new block ID generated in the step S26;
the method for modifying the NANDFLASH driver based on the designed algorithm for automatically skipping bad blocks in the step S3 comprises the following sub-steps:
for read and write operations, two functions of a spin_read_page () and a spin_program_page () in a kernel file nand_spin.c file are modified, and an incoming page ID is converted into a corresponding block ID; then, calling an algorithm designed in the step S2 for automatically skipping bad blocks to acquire new block IDs, and converting the acquired new block IDs into new page IDs; finally, using the new page ID to operate NANDFLASH;
for the erasing operation, the spin_erase_block () function directly calls the algorithm designed in step S2 to automatically skip bad blocks to obtain new IDs, and then performs block erasing on the new IDs.
2. The method for managing bad blocks of NANDFLASH file system based on LINUX operating system according to claim 1, wherein the method for obtaining bad blocks of NANDFLASH in step S1 comprises the following sub-steps:
s11, defining a shaping array and a shaping variable in a kernel file nand_bbt.c file; the shaping array is used for storing bad block IDs of NANDFLASH; the shaping variable is used for recording the total number of bad blocks;
s12, storing bad block IDs scanned by the create_bbt () function into a shaping array, and recording the total number of bad blocks by using shaping variables;
s13, the total number of the shaping array and the bad blocks is derived by utilizing the kernel EXPORT_SYMBOL macro.
3. The method for managing bad blocks of a NANDFLASH file-free system based on an LINUX operation system according to claim 2, wherein bad block IDs stored in said shaping array are arranged from small to large.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110819797.8A CN113742283B (en) | 2021-07-20 | 2021-07-20 | NANDFLASH non-file system bad block management method based on LINUX operation system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110819797.8A CN113742283B (en) | 2021-07-20 | 2021-07-20 | NANDFLASH non-file system bad block management method based on LINUX operation system |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN113742283A CN113742283A (en) | 2021-12-03 |
| CN113742283B true CN113742283B (en) | 2023-11-24 |
Family
ID=78728768
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110819797.8A Active CN113742283B (en) | 2021-07-20 | 2021-07-20 | NANDFLASH non-file system bad block management method based on LINUX operation system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113742283B (en) |
Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101809546A (en) * | 2008-02-18 | 2010-08-18 | 中兴通讯股份有限公司 | Device for implementing file system on nandflash of mobile terminal |
| CN102331911A (en) * | 2011-06-17 | 2012-01-25 | 杭州华三通信技术有限公司 | Driving device and method for writing data to Nand Flash by file system |
| CN105354218A (en) * | 2015-09-29 | 2016-02-24 | 成都嘉泰华力科技有限责任公司 | YAFFS file system based on VxWorks transplantation |
| CN105740163A (en) * | 2016-01-29 | 2016-07-06 | 山东鲁能智能技术有限公司 | Nand Flash bad block management method |
| CN106095620A (en) * | 2013-09-23 | 2016-11-09 | 恒鸿达科技有限公司 | A kind of development approach of built-in Linux partition holding |
| CN106445398A (en) * | 2015-08-04 | 2017-02-22 | 深圳市中兴微电子技术有限公司 | Novel memory-based embedded file system and realization method thereof |
| CN106951189A (en) * | 2017-03-17 | 2017-07-14 | 数据通信科学技术研究所 | A kind of method that online depth wipes FLASH files |
Family Cites Families (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US10380022B2 (en) * | 2011-07-28 | 2019-08-13 | Netlist, Inc. | Hybrid memory module and system and method of operating the same |
| US10496548B2 (en) * | 2018-02-07 | 2019-12-03 | Alibaba Group Holding Limited | Method and system for user-space storage I/O stack with user-space flash translation layer |
-
2021
- 2021-07-20 CN CN202110819797.8A patent/CN113742283B/en active Active
Patent Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101809546A (en) * | 2008-02-18 | 2010-08-18 | 中兴通讯股份有限公司 | Device for implementing file system on nandflash of mobile terminal |
| CN102331911A (en) * | 2011-06-17 | 2012-01-25 | 杭州华三通信技术有限公司 | Driving device and method for writing data to Nand Flash by file system |
| CN106095620A (en) * | 2013-09-23 | 2016-11-09 | 恒鸿达科技有限公司 | A kind of development approach of built-in Linux partition holding |
| CN106445398A (en) * | 2015-08-04 | 2017-02-22 | 深圳市中兴微电子技术有限公司 | Novel memory-based embedded file system and realization method thereof |
| CN105354218A (en) * | 2015-09-29 | 2016-02-24 | 成都嘉泰华力科技有限责任公司 | YAFFS file system based on VxWorks transplantation |
| CN105740163A (en) * | 2016-01-29 | 2016-07-06 | 山东鲁能智能技术有限公司 | Nand Flash bad block management method |
| CN106951189A (en) * | 2017-03-17 | 2017-07-14 | 数据通信科学技术研究所 | A kind of method that online depth wipes FLASH files |
Non-Patent Citations (1)
| Title |
|---|
| "一种新型NAND Flash坏块管理算法的研究与实现";乔立岩 等;《电子测量技术》;第38卷(第11期);第37-41页 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN113742283A (en) | 2021-12-03 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US7610434B2 (en) | File recording apparatus | |
| US20080195833A1 (en) | Systems, methods and computer program products for operating a data processing system in which a file system's unit of memory allocation is coordinated with a storage system's read/write operation unit | |
| JP2008112445A (en) | Apparatus and method for managing nonvolatile memory | |
| US5768582A (en) | Computer program product for domained incremental changes storage and retrieval | |
| CN100382049C (en) | Data processing apparatus and method for flash memory | |
| CN101620651B (en) | Method and device for clearing data in computer | |
| KR20080085574A (en) | Apparatus and method for garbage collection of non-volatile memory | |
| US20080301393A1 (en) | Apparatus and method of processing data of non-volatile memory | |
| CN104035842A (en) | Method for deleting and recovering built-in application program | |
| CN101452422A (en) | Chip data read-write method, corresponding apparatus and system | |
| CN113377579A (en) | Mapping table-based solid state disk data recovery method and system | |
| CN113742283B (en) | NANDFLASH non-file system bad block management method based on LINUX operation system | |
| US20200012487A1 (en) | Firmware Updating Method | |
| CN103218300B (en) | Data processing method, Memory Controller and memorizer memory devices | |
| JP2008123314A (en) | Information recording method and information recording system to semiconductor storage device | |
| RU2615072C2 (en) | Information processing method and device and recording medium | |
| CN113836600B (en) | Embedded Flash error writing protection method | |
| CN107193558B (en) | Log file generation method and device | |
| CN106021124B (en) | A kind of storage method and storage system of data | |
| WO2019007315A1 (en) | Data writing method in flash memory device, and device | |
| CN111813708B (en) | Block mapping system and method for storage device | |
| CN114840426A (en) | Code testing method and device | |
| CN110990018B (en) | Compiling method and compiling system of embedded system | |
| CN112286572A (en) | Configuration method and device of business process | |
| KR100695241B1 (en) | Method for Saving Storage Space of Random Access Memory Used in Mobile Phone and Mobile Phone Therewith |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |