WebSVN – freemyipod – Diff – /embios/trunk/target/ipodnano2g/ftl.c

         if (j == 4) continue;
         ftl_vfl_cxt[bank].activecxtblock = i;
         ftl_vfl_cxt[bank].nextcxtpage = 0;
         if (ftl_vfl_store_cxt(bank) == 0) return 0;
+    }
+    ftl_initialized = false;
-    panicf(PANIC_FATAL, "VFL: Failed to commit VFL CXT!");
+    panicf(PANIC_KILLTHREAD, "VFL: Failed to commit VFL CXT!");
     return 1;
+}
 #endif
 #ifndef FTL_READONLY
 /* Schedules remapping for the specified bank and vBlock */
 static void ftl_vfl_schedule_block_for_remap(uint32_t bank, uint32_t block)
+{
     if (ftl_vfl_check_remap_scheduled(bank, block) == 1) return;
+    ftl_initialized = false;
-    panicf(PANIC_FATAL, "FTL: Scheduling bank %u block %u for remap!",
+    panicf(PANIC_KILLTHREAD, "FTL: Scheduling bank %u block %u for remap!",
            (unsigned)bank, (unsigned)block);
     if (ftl_vfl_cxt[bank].scheduledstart == ftl_vfl_cxt[bank].spareused)
         return;
     ftl_vfl_cxt[bank].remaptable[--ftl_vfl_cxt[bank].scheduledstart] = block;
     ftl_vfl_commit_cxt(bank);
    if not (no more spare blocks available), it will return zero. */
 static uint32_t ftl_vfl_remap_block(uint32_t bank, uint32_t block)
+{
     uint32_t i;
     uint32_t newblock = 0, newidx;
+    ftl_initialized = false;
-    panicf(PANIC_FATAL, "FTL: Remapping bank %u block %u!",
+    panicf(PANIC_KILLTHREAD, "FTL: Remapping bank %u block %u!",
            (unsigned)bank, (unsigned)block);
     if (bank >= ftl_banks || block >= ftl_nand_type->blocks) return 0;
     for (i = 0; i < ftl_vfl_cxt[bank].sparecount; i++)
         if (ftl_vfl_cxt[bank].remaptable[i] == 0)
+        {
         if (i >= ftl_banks)
             if (nand_write_page_collect(bank[ftl_banks]))
                 if (nand_read_page(bank[ftl_banks], physpage[ftl_banks],
                                    ftl_buffer, &ftl_sparebuffer[0], 1, 1) & 0x11F)
+                {
+                    ftl_initialized = false;
-                    panicf(PANIC_FATAL, "FTL: write error (2) on vPage %u, bank %u, pPage %u",
+                    panicf(PANIC_KILLTHREAD, "FTL: write error (2) on vPage %u, bank %u, pPage %u",
                            (unsigned)(vpage + i - ftl_banks),
                            (unsigned)bank[ftl_banks],
                            (unsigned)physpage[ftl_banks]);
                     ftl_vfl_log_trouble(bank[ftl_banks], block[ftl_banks]);
+                }
                                   (void*)((uint32_t)buffer + 0x800 * i),
                                   (void*)((uint32_t)sparebuffer + 0x40 * i), 1))
             if (nand_read_page(bank[0], physpage[0], ftl_buffer,
                                &ftl_sparebuffer[0], 1, 1) & 0x11F)
+            {
+                ftl_initialized = false;
-                panicf(PANIC_FATAL, "FTL: write error (1) on vPage %u, bank %u, pPage %u",
+                panicf(PANIC_KILLTHREAD, "FTL: write error (1) on vPage %u, bank %u, pPage %u",
                        (unsigned)(vpage + i), (unsigned)bank[0], (unsigned)physpage[0]);
                 ftl_vfl_log_trouble(bank[0], block[0]);
+            }
+    }
     for (i = count < ftl_banks ? count : ftl_banks; i > 0; i--)
         if (nand_write_page_collect(bank[i - 1]))
             if (nand_read_page(bank[i - 1], physpage[i - 1],
                                ftl_buffer, &ftl_sparebuffer[0], 1, 1) & 0x11F)
+            {
+                ftl_initialized = false;
-                panicf(PANIC_FATAL, "FTL: write error (2) on vPage %u, bank %u, pPage %u",
+                panicf(PANIC_KILLTHREAD, "FTL: write error (2) on vPage %u, bank %u, pPage %u",
                        (unsigned)(vpage + count - i),
                        (unsigned)bank[i - 1], (unsigned)physpage[i - 1]);
                 ftl_vfl_log_trouble(bank[i - 1], block[i - 1]);
+            }
                             last = k;
+                        }
                         if (ftl_vfl_read_page(i, vflcxtblock[vflcxtidx],
                                               last, ftl_buffer,
                                               &ftl_sparebuffer[0]) != 0)
+                        {
+                            ftl_initialized = false;
-                            panicf(PANIC_FATAL, "FTL: Re-reading VFL CXT block "
+                            panicf(PANIC_KILLTHREAD, "FTL: Re-reading VFL CXT block "
-                                        "on bank %u failed!?", (unsigned)i);
+                                                     "on bank %u failed!?", (unsigned)i);
                             //return 1;
+                        }
                         memcpy(&ftl_vfl_cxt[i], ftl_buffer, 0x800);
                         if (ftl_vfl_verify_checksum(i) != 0) return 1;
 #ifndef FTL_READONLY
                         if (ftl_vfl_usn < ftl_vfl_cxt[i].usn)
                             ftl_vfl_usn = ftl_vfl_cxt[i].usn;
         return -2;
+    }
     if (count == 0) return 0;
     mutex_lock(&ftl_mtx, TIMEOUT_BLOCK);
+    if (!ftl_initialized)
+    {
+        mutex_unlock(&ftl_mtx);
+        return -1;
+    }
     for (i = 0; i < count; i++)
+    {
         uint32_t block = (sector + i) / ppb;
         uint32_t page = (sector + i) % ppb;
             rc = nand_block_erase(i, pblock * ftl_nand_type->pagesperblock);
             if (rc == 0) break;
+        }
         if (rc != 0)
+        {
+            ftl_initialized = false;
-            panicf(PANIC_FATAL, "FTL: Block erase failed on bank %u block %u",
+            panicf(PANIC_KILLTHREAD, "FTL: Block erase failed on bank %u block %u",
                    (unsigned)i, (unsigned)block);
             if (pblock != block)
+            {
                 uint32_t spareindex = pblock - ftl_vfl_cxt[i].firstspare;
                 ftl_vfl_cxt[i].remaptable[spareindex] = 0xFFFF;
+        {
             erasectr = ftl_erasectr[ftl_cxt.blockpool[idx]];
             bestidx = idx;
+        }
+    }
+    if (bestidx == 0xFFFFFFFF0)
+    {
+        ftl_initialized = false;
-    if (bestidx == 0xFFFFFFFF) panicf(PANIC_FATAL, "FTL: Out of pool blocks!");
+        panicf(PANIC_KILLTHREAD, "FTL: Out of pool blocks!");
+    }
     block = ftl_cxt.blockpool[bestidx];
     if (bestidx != ftl_cxt.nextfreeidx)
+    {
         ftl_cxt.blockpool[bestidx] = ftl_cxt.blockpool[ftl_cxt.nextfreeidx];
         ftl_cxt.blockpool[ftl_cxt.nextfreeidx] = block;
+    }
     if (block > (uint32_t)ftl_nand_type->userblocks + 0x17)
+    {
+        ftl_initialized = false;
-        panicf(PANIC_FATAL, "FTL: Bad block number in pool: %u", (unsigned)block);
+        panicf(PANIC_KILLTHREAD, "FTL: Bad block number in pool: %u", (unsigned)block);
+    }
     if (ftl_erase_block(block) != 0) return 0xFFFFFFFF;
     if (++ftl_cxt.nextfreeidx == 0x14) ftl_cxt.nextfreeidx = 0;
     ftl_cxt.freecount--;
     return block;
+}
 #ifndef FTL_READONLY
 /* Releases a vBlock back into the pool */
 static void ftl_release_pool_block(uint32_t block)
+{
     if (block >= (uint32_t)ftl_nand_type->userblocks + 0x17)
+    {
+        ftl_initialized = false;
-        panicf(PANIC_FATAL, "FTL: Tried to release block %u", (unsigned)block);
+        panicf(PANIC_KILLTHREAD, "FTL: Tried to release block %u", (unsigned)block);
+    }
     uint32_t idx = ftl_cxt.nextfreeidx + ftl_cxt.freecount++;
     if (idx >= 0x14) idx -= 0x14;
     ftl_cxt.blockpool[idx] = block;
+}
 #endif
+        }
+    }
     if (entry == NULL)
+    {
+        if (ftl_cxt.freecount < 3)
+        {
+            ftl_initialized = false;
-        if (ftl_cxt.freecount < 3) panicf(PANIC_FATAL, "FTL: Detected a pool block leak!");
+            panicf(PANIC_KILLTHREAD, "FTL: Detected a pool block leak!");
+        }
         else if (ftl_cxt.freecount == 3)
             if (ftl_remove_scattered_block(NULL) != 0)
                 return NULL;
         entry = ftl_log;
         while (entry->scatteredvblock != 0xFFFF) entry = &entry[1];
         return -2;
+    }
     if (count == 0) return 0;
     mutex_lock(&ftl_mtx, TIMEOUT_BLOCK);
+    if (!ftl_initialized)
+    {
+        mutex_unlock(&ftl_mtx);
+        return -1;
+    }
     if (ftl_cxt.clean_flag == 1)
+    {
         for (i = 0; i < 3; i++)
+        {
                      || logentry->pageoffsets[page + j] != page + j)
                         logentry->issequential = 0;
+                }
                 i += cnt;
+            }
+            else
+            {
+                ftl_initialized = false;
-            else panicf(PANIC_FATAL, "FTL: Write error: %u %u %u!",
+                panicf(PANIC_KILLTHREAD, "FTL: Write error: %u %u %u!",
-                        (unsigned)sector, (unsigned)count, (unsigned)i);
+                       (unsigned)sector, (unsigned)count, (unsigned)i);
+            }
+        }
         if (logentry->pagesused == ppb) ftl_remove_scattered_block(logentry);
+    }
     if (ftl_cxt.swapcounter >= 300)
+    {
     if (!ftl_initialized) return 0;
     if (ftl_cxt.clean_flag == 1) return 0;
     mutex_lock(&ftl_mtx, TIMEOUT_BLOCK);
+    if (!ftl_initialized)
+    {
+        mutex_unlock(&ftl_mtx);
+        return -1;
+    }
 #ifdef FTL_TRACE
     DEBUGF("FTL: Syncing");
 #endif
     if (ftl_initialized) return 0;
     mutex_init(&ftl_mtx);
     uint32_t i;
     int rc;
     if ((rc = nand_device_init()) != 0)
-        panicf(PANIC_FATAL, "FTL: Lowlevel NAND driver init failed: %d", rc);
+        panicf(PANIC_KILLTHREAD, "FTL: Lowlevel NAND driver init failed: %d", rc);
     ftl_banks = 0;
     for (i = 0; i < 4; i++)
         if (nand_get_device_type(i) != 0) ftl_banks = i + 1;
     ftl_nand_type = nand_get_device_type(0);
         if (ftl_open() == 0)
+        {
             ftl_initialized = true;
             return 0;
+        }
-        cputs(CONSOLE_BOOT, "The FTL seems to be damaged. Forcing check.\n");
+        cputs(CONSOLE_BOOT, "The FTL seems to be unclean. Forcing check.\n");
         if (ftl_repair() != 0)
             cputs(CONSOLE_BOOT, "FTL recovery failed. Use disk mode to recover.\n");
         else
+        {
             cputs(CONSOLE_BOOT, "FTL recovery finished. Trying to mount again...\n");

Subversion Repositories freemyipod

(root)/embios/trunk/target/ipodnano2g/ftl.c @ 249 – Rev 227 → 249