fastmap.c 41 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699
  1. /*
  2. * Copyright (c) 2012 Linutronix GmbH
  3. * Copyright (c) 2014 sigma star gmbh
  4. * Author: Richard Weinberger <richard@nod.at>
  5. *
  6. * This program is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License as published by
  8. * the Free Software Foundation; version 2.
  9. *
  10. * This program is distributed in the hope that it will be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
  13. * the GNU General Public License for more details.
  14. *
  15. */
  16. #include <linux/crc32.h>
  17. #include <linux/bitmap.h>
  18. #include "ubi.h"
  19. /**
  20. * init_seen - allocate memory for used for debugging.
  21. * @ubi: UBI device description object
  22. */
  23. static inline unsigned long *init_seen(struct ubi_device *ubi)
  24. {
  25. unsigned long *ret;
  26. if (!ubi_dbg_chk_fastmap(ubi))
  27. return NULL;
  28. ret = kcalloc(BITS_TO_LONGS(ubi->peb_count), sizeof(unsigned long),
  29. GFP_KERNEL);
  30. if (!ret)
  31. return ERR_PTR(-ENOMEM);
  32. return ret;
  33. }
  34. /**
  35. * free_seen - free the seen logic integer array.
  36. * @seen: integer array of @ubi->peb_count size
  37. */
  38. static inline void free_seen(unsigned long *seen)
  39. {
  40. kfree(seen);
  41. }
  42. /**
  43. * set_seen - mark a PEB as seen.
  44. * @ubi: UBI device description object
  45. * @pnum: The PEB to be makred as seen
  46. * @seen: integer array of @ubi->peb_count size
  47. */
  48. static inline void set_seen(struct ubi_device *ubi, int pnum, unsigned long *seen)
  49. {
  50. if (!ubi_dbg_chk_fastmap(ubi) || !seen)
  51. return;
  52. set_bit(pnum, seen);
  53. }
  54. /**
  55. * self_check_seen - check whether all PEB have been seen by fastmap.
  56. * @ubi: UBI device description object
  57. * @seen: integer array of @ubi->peb_count size
  58. */
  59. static int self_check_seen(struct ubi_device *ubi, unsigned long *seen)
  60. {
  61. int pnum, ret = 0;
  62. if (!ubi_dbg_chk_fastmap(ubi) || !seen)
  63. return 0;
  64. for (pnum = 0; pnum < ubi->peb_count; pnum++) {
  65. if (test_bit(pnum, seen) && ubi->lookuptbl[pnum]) {
  66. ubi_err(ubi, "self-check failed for PEB %d, fastmap didn't see it", pnum);
  67. ret = -EINVAL;
  68. }
  69. }
  70. return ret;
  71. }
  72. /**
  73. * ubi_calc_fm_size - calculates the fastmap size in bytes for an UBI device.
  74. * @ubi: UBI device description object
  75. */
  76. size_t ubi_calc_fm_size(struct ubi_device *ubi)
  77. {
  78. size_t size;
  79. size = sizeof(struct ubi_fm_sb) +
  80. sizeof(struct ubi_fm_hdr) +
  81. sizeof(struct ubi_fm_scan_pool) +
  82. sizeof(struct ubi_fm_scan_pool) +
  83. (ubi->peb_count * sizeof(struct ubi_fm_ec)) +
  84. (sizeof(struct ubi_fm_eba) +
  85. (ubi->peb_count * sizeof(__be32))) +
  86. sizeof(struct ubi_fm_volhdr) * UBI_MAX_VOLUMES;
  87. return roundup(size, ubi->leb_size);
  88. }
  89. /**
  90. * new_fm_vhdr - allocate a new volume header for fastmap usage.
  91. * @ubi: UBI device description object
  92. * @vol_id: the VID of the new header
  93. *
  94. * Returns a new struct ubi_vid_hdr on success.
  95. * NULL indicates out of memory.
  96. */
  97. static struct ubi_vid_io_buf *new_fm_vbuf(struct ubi_device *ubi, int vol_id)
  98. {
  99. struct ubi_vid_io_buf *new;
  100. struct ubi_vid_hdr *vh;
  101. new = ubi_alloc_vid_buf(ubi, GFP_KERNEL);
  102. if (!new)
  103. goto out;
  104. vh = ubi_get_vid_hdr(new);
  105. vh->vol_type = UBI_VID_DYNAMIC;
  106. vh->vol_id = cpu_to_be32(vol_id);
  107. /* UBI implementations without fastmap support have to delete the
  108. * fastmap.
  109. */
  110. vh->compat = UBI_COMPAT_DELETE;
  111. out:
  112. return new;
  113. }
  114. /**
  115. * add_aeb - create and add a attach erase block to a given list.
  116. * @ai: UBI attach info object
  117. * @list: the target list
  118. * @pnum: PEB number of the new attach erase block
  119. * @ec: erease counter of the new LEB
  120. * @scrub: scrub this PEB after attaching
  121. *
  122. * Returns 0 on success, < 0 indicates an internal error.
  123. */
  124. static int add_aeb(struct ubi_attach_info *ai, struct list_head *list,
  125. int pnum, int ec, int scrub)
  126. {
  127. struct ubi_ainf_peb *aeb;
  128. aeb = ubi_alloc_aeb(ai, pnum, ec);
  129. if (!aeb)
  130. return -ENOMEM;
  131. aeb->lnum = -1;
  132. aeb->scrub = scrub;
  133. aeb->copy_flag = aeb->sqnum = 0;
  134. ai->ec_sum += aeb->ec;
  135. ai->ec_count++;
  136. if (ai->max_ec < aeb->ec)
  137. ai->max_ec = aeb->ec;
  138. if (ai->min_ec > aeb->ec)
  139. ai->min_ec = aeb->ec;
  140. list_add_tail(&aeb->u.list, list);
  141. return 0;
  142. }
  143. /**
  144. * add_vol - create and add a new volume to ubi_attach_info.
  145. * @ai: ubi_attach_info object
  146. * @vol_id: VID of the new volume
  147. * @used_ebs: number of used EBS
  148. * @data_pad: data padding value of the new volume
  149. * @vol_type: volume type
  150. * @last_eb_bytes: number of bytes in the last LEB
  151. *
  152. * Returns the new struct ubi_ainf_volume on success.
  153. * NULL indicates an error.
  154. */
  155. static struct ubi_ainf_volume *add_vol(struct ubi_attach_info *ai, int vol_id,
  156. int used_ebs, int data_pad, u8 vol_type,
  157. int last_eb_bytes)
  158. {
  159. struct ubi_ainf_volume *av;
  160. av = ubi_add_av(ai, vol_id);
  161. if (IS_ERR(av))
  162. return av;
  163. av->data_pad = data_pad;
  164. av->last_data_size = last_eb_bytes;
  165. av->compat = 0;
  166. av->vol_type = vol_type;
  167. if (av->vol_type == UBI_STATIC_VOLUME)
  168. av->used_ebs = used_ebs;
  169. dbg_bld("found volume (ID %i)", vol_id);
  170. return av;
  171. }
  172. /**
  173. * assign_aeb_to_av - assigns a SEB to a given ainf_volume and removes it
  174. * from it's original list.
  175. * @ai: ubi_attach_info object
  176. * @aeb: the to be assigned SEB
  177. * @av: target scan volume
  178. */
  179. static void assign_aeb_to_av(struct ubi_attach_info *ai,
  180. struct ubi_ainf_peb *aeb,
  181. struct ubi_ainf_volume *av)
  182. {
  183. struct ubi_ainf_peb *tmp_aeb;
  184. struct rb_node **p = &av->root.rb_node, *parent = NULL;
  185. while (*p) {
  186. parent = *p;
  187. tmp_aeb = rb_entry(parent, struct ubi_ainf_peb, u.rb);
  188. if (aeb->lnum != tmp_aeb->lnum) {
  189. if (aeb->lnum < tmp_aeb->lnum)
  190. p = &(*p)->rb_left;
  191. else
  192. p = &(*p)->rb_right;
  193. continue;
  194. } else
  195. break;
  196. }
  197. list_del(&aeb->u.list);
  198. av->leb_count++;
  199. rb_link_node(&aeb->u.rb, parent, p);
  200. rb_insert_color(&aeb->u.rb, &av->root);
  201. }
  202. /**
  203. * update_vol - inserts or updates a LEB which was found a pool.
  204. * @ubi: the UBI device object
  205. * @ai: attach info object
  206. * @av: the volume this LEB belongs to
  207. * @new_vh: the volume header derived from new_aeb
  208. * @new_aeb: the AEB to be examined
  209. *
  210. * Returns 0 on success, < 0 indicates an internal error.
  211. */
  212. static int update_vol(struct ubi_device *ubi, struct ubi_attach_info *ai,
  213. struct ubi_ainf_volume *av, struct ubi_vid_hdr *new_vh,
  214. struct ubi_ainf_peb *new_aeb)
  215. {
  216. struct rb_node **p = &av->root.rb_node, *parent = NULL;
  217. struct ubi_ainf_peb *aeb, *victim;
  218. int cmp_res;
  219. while (*p) {
  220. parent = *p;
  221. aeb = rb_entry(parent, struct ubi_ainf_peb, u.rb);
  222. if (be32_to_cpu(new_vh->lnum) != aeb->lnum) {
  223. if (be32_to_cpu(new_vh->lnum) < aeb->lnum)
  224. p = &(*p)->rb_left;
  225. else
  226. p = &(*p)->rb_right;
  227. continue;
  228. }
  229. /* This case can happen if the fastmap gets written
  230. * because of a volume change (creation, deletion, ..).
  231. * Then a PEB can be within the persistent EBA and the pool.
  232. */
  233. if (aeb->pnum == new_aeb->pnum) {
  234. ubi_assert(aeb->lnum == new_aeb->lnum);
  235. ubi_free_aeb(ai, new_aeb);
  236. return 0;
  237. }
  238. cmp_res = ubi_compare_lebs(ubi, aeb, new_aeb->pnum, new_vh);
  239. if (cmp_res < 0)
  240. return cmp_res;
  241. /* new_aeb is newer */
  242. if (cmp_res & 1) {
  243. victim = ubi_alloc_aeb(ai, aeb->pnum, aeb->ec);
  244. if (!victim)
  245. return -ENOMEM;
  246. list_add_tail(&victim->u.list, &ai->erase);
  247. if (av->highest_lnum == be32_to_cpu(new_vh->lnum))
  248. av->last_data_size =
  249. be32_to_cpu(new_vh->data_size);
  250. dbg_bld("vol %i: AEB %i's PEB %i is the newer",
  251. av->vol_id, aeb->lnum, new_aeb->pnum);
  252. aeb->ec = new_aeb->ec;
  253. aeb->pnum = new_aeb->pnum;
  254. aeb->copy_flag = new_vh->copy_flag;
  255. aeb->scrub = new_aeb->scrub;
  256. aeb->sqnum = new_aeb->sqnum;
  257. ubi_free_aeb(ai, new_aeb);
  258. /* new_aeb is older */
  259. } else {
  260. dbg_bld("vol %i: AEB %i's PEB %i is old, dropping it",
  261. av->vol_id, aeb->lnum, new_aeb->pnum);
  262. list_add_tail(&new_aeb->u.list, &ai->erase);
  263. }
  264. return 0;
  265. }
  266. /* This LEB is new, let's add it to the volume */
  267. if (av->highest_lnum <= be32_to_cpu(new_vh->lnum)) {
  268. av->highest_lnum = be32_to_cpu(new_vh->lnum);
  269. av->last_data_size = be32_to_cpu(new_vh->data_size);
  270. }
  271. if (av->vol_type == UBI_STATIC_VOLUME)
  272. av->used_ebs = be32_to_cpu(new_vh->used_ebs);
  273. av->leb_count++;
  274. rb_link_node(&new_aeb->u.rb, parent, p);
  275. rb_insert_color(&new_aeb->u.rb, &av->root);
  276. return 0;
  277. }
  278. /**
  279. * process_pool_aeb - we found a non-empty PEB in a pool.
  280. * @ubi: UBI device object
  281. * @ai: attach info object
  282. * @new_vh: the volume header derived from new_aeb
  283. * @new_aeb: the AEB to be examined
  284. *
  285. * Returns 0 on success, < 0 indicates an internal error.
  286. */
  287. static int process_pool_aeb(struct ubi_device *ubi, struct ubi_attach_info *ai,
  288. struct ubi_vid_hdr *new_vh,
  289. struct ubi_ainf_peb *new_aeb)
  290. {
  291. int vol_id = be32_to_cpu(new_vh->vol_id);
  292. struct ubi_ainf_volume *av;
  293. if (vol_id == UBI_FM_SB_VOLUME_ID || vol_id == UBI_FM_DATA_VOLUME_ID) {
  294. ubi_free_aeb(ai, new_aeb);
  295. return 0;
  296. }
  297. /* Find the volume this SEB belongs to */
  298. av = ubi_find_av(ai, vol_id);
  299. if (!av) {
  300. ubi_err(ubi, "orphaned volume in fastmap pool!");
  301. ubi_free_aeb(ai, new_aeb);
  302. return UBI_BAD_FASTMAP;
  303. }
  304. ubi_assert(vol_id == av->vol_id);
  305. return update_vol(ubi, ai, av, new_vh, new_aeb);
  306. }
  307. /**
  308. * unmap_peb - unmap a PEB.
  309. * If fastmap detects a free PEB in the pool it has to check whether
  310. * this PEB has been unmapped after writing the fastmap.
  311. *
  312. * @ai: UBI attach info object
  313. * @pnum: The PEB to be unmapped
  314. */
  315. static void unmap_peb(struct ubi_attach_info *ai, int pnum)
  316. {
  317. struct ubi_ainf_volume *av;
  318. struct rb_node *node, *node2;
  319. struct ubi_ainf_peb *aeb;
  320. ubi_rb_for_each_entry(node, av, &ai->volumes, rb) {
  321. ubi_rb_for_each_entry(node2, aeb, &av->root, u.rb) {
  322. if (aeb->pnum == pnum) {
  323. rb_erase(&aeb->u.rb, &av->root);
  324. av->leb_count--;
  325. ubi_free_aeb(ai, aeb);
  326. return;
  327. }
  328. }
  329. }
  330. }
  331. /**
  332. * scan_pool - scans a pool for changed (no longer empty PEBs).
  333. * @ubi: UBI device object
  334. * @ai: attach info object
  335. * @pebs: an array of all PEB numbers in the to be scanned pool
  336. * @pool_size: size of the pool (number of entries in @pebs)
  337. * @max_sqnum: pointer to the maximal sequence number
  338. * @free: list of PEBs which are most likely free (and go into @ai->free)
  339. *
  340. * Returns 0 on success, if the pool is unusable UBI_BAD_FASTMAP is returned.
  341. * < 0 indicates an internal error.
  342. */
  343. static int scan_pool(struct ubi_device *ubi, struct ubi_attach_info *ai,
  344. __be32 *pebs, int pool_size, unsigned long long *max_sqnum,
  345. struct list_head *free)
  346. {
  347. struct ubi_vid_io_buf *vb;
  348. struct ubi_vid_hdr *vh;
  349. struct ubi_ec_hdr *ech;
  350. struct ubi_ainf_peb *new_aeb;
  351. int i, pnum, err, ret = 0;
  352. ech = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);
  353. if (!ech)
  354. return -ENOMEM;
  355. vb = ubi_alloc_vid_buf(ubi, GFP_KERNEL);
  356. if (!vb) {
  357. kfree(ech);
  358. return -ENOMEM;
  359. }
  360. vh = ubi_get_vid_hdr(vb);
  361. dbg_bld("scanning fastmap pool: size = %i", pool_size);
  362. /*
  363. * Now scan all PEBs in the pool to find changes which have been made
  364. * after the creation of the fastmap
  365. */
  366. for (i = 0; i < pool_size; i++) {
  367. int scrub = 0;
  368. int image_seq;
  369. pnum = be32_to_cpu(pebs[i]);
  370. if (ubi_io_is_bad(ubi, pnum)) {
  371. ubi_err(ubi, "bad PEB in fastmap pool!");
  372. ret = UBI_BAD_FASTMAP;
  373. goto out;
  374. }
  375. err = ubi_io_read_ec_hdr(ubi, pnum, ech, 0);
  376. if (err && err != UBI_IO_BITFLIPS) {
  377. ubi_err(ubi, "unable to read EC header! PEB:%i err:%i",
  378. pnum, err);
  379. ret = err > 0 ? UBI_BAD_FASTMAP : err;
  380. goto out;
  381. } else if (err == UBI_IO_BITFLIPS)
  382. scrub = 1;
  383. /*
  384. * Older UBI implementations have image_seq set to zero, so
  385. * we shouldn't fail if image_seq == 0.
  386. */
  387. image_seq = be32_to_cpu(ech->image_seq);
  388. if (image_seq && (image_seq != ubi->image_seq)) {
  389. ubi_err(ubi, "bad image seq: 0x%x, expected: 0x%x",
  390. be32_to_cpu(ech->image_seq), ubi->image_seq);
  391. ret = UBI_BAD_FASTMAP;
  392. goto out;
  393. }
  394. err = ubi_io_read_vid_hdr(ubi, pnum, vb, 0);
  395. if (err == UBI_IO_FF || err == UBI_IO_FF_BITFLIPS) {
  396. unsigned long long ec = be64_to_cpu(ech->ec);
  397. unmap_peb(ai, pnum);
  398. dbg_bld("Adding PEB to free: %i", pnum);
  399. if (err == UBI_IO_FF_BITFLIPS)
  400. scrub = 1;
  401. add_aeb(ai, free, pnum, ec, scrub);
  402. continue;
  403. } else if (err == 0 || err == UBI_IO_BITFLIPS) {
  404. dbg_bld("Found non empty PEB:%i in pool", pnum);
  405. if (err == UBI_IO_BITFLIPS)
  406. scrub = 1;
  407. new_aeb = ubi_alloc_aeb(ai, pnum, be64_to_cpu(ech->ec));
  408. if (!new_aeb) {
  409. ret = -ENOMEM;
  410. goto out;
  411. }
  412. new_aeb->lnum = be32_to_cpu(vh->lnum);
  413. new_aeb->sqnum = be64_to_cpu(vh->sqnum);
  414. new_aeb->copy_flag = vh->copy_flag;
  415. new_aeb->scrub = scrub;
  416. if (*max_sqnum < new_aeb->sqnum)
  417. *max_sqnum = new_aeb->sqnum;
  418. err = process_pool_aeb(ubi, ai, vh, new_aeb);
  419. if (err) {
  420. ret = err > 0 ? UBI_BAD_FASTMAP : err;
  421. goto out;
  422. }
  423. } else {
  424. /* We are paranoid and fall back to scanning mode */
  425. ubi_err(ubi, "fastmap pool PEBs contains damaged PEBs!");
  426. ret = err > 0 ? UBI_BAD_FASTMAP : err;
  427. goto out;
  428. }
  429. }
  430. out:
  431. ubi_free_vid_buf(vb);
  432. kfree(ech);
  433. return ret;
  434. }
  435. /**
  436. * count_fastmap_pebs - Counts the PEBs found by fastmap.
  437. * @ai: The UBI attach info object
  438. */
  439. static int count_fastmap_pebs(struct ubi_attach_info *ai)
  440. {
  441. struct ubi_ainf_peb *aeb;
  442. struct ubi_ainf_volume *av;
  443. struct rb_node *rb1, *rb2;
  444. int n = 0;
  445. list_for_each_entry(aeb, &ai->erase, u.list)
  446. n++;
  447. list_for_each_entry(aeb, &ai->free, u.list)
  448. n++;
  449. ubi_rb_for_each_entry(rb1, av, &ai->volumes, rb)
  450. ubi_rb_for_each_entry(rb2, aeb, &av->root, u.rb)
  451. n++;
  452. return n;
  453. }
  454. /**
  455. * ubi_attach_fastmap - creates ubi_attach_info from a fastmap.
  456. * @ubi: UBI device object
  457. * @ai: UBI attach info object
  458. * @fm: the fastmap to be attached
  459. *
  460. * Returns 0 on success, UBI_BAD_FASTMAP if the found fastmap was unusable.
  461. * < 0 indicates an internal error.
  462. */
  463. static int ubi_attach_fastmap(struct ubi_device *ubi,
  464. struct ubi_attach_info *ai,
  465. struct ubi_fastmap_layout *fm)
  466. {
  467. struct list_head used, free;
  468. struct ubi_ainf_volume *av;
  469. struct ubi_ainf_peb *aeb, *tmp_aeb, *_tmp_aeb;
  470. struct ubi_fm_sb *fmsb;
  471. struct ubi_fm_hdr *fmhdr;
  472. struct ubi_fm_scan_pool *fmpl, *fmpl_wl;
  473. struct ubi_fm_ec *fmec;
  474. struct ubi_fm_volhdr *fmvhdr;
  475. struct ubi_fm_eba *fm_eba;
  476. int ret, i, j, pool_size, wl_pool_size;
  477. size_t fm_pos = 0, fm_size = ubi->fm_size;
  478. unsigned long long max_sqnum = 0;
  479. void *fm_raw = ubi->fm_buf;
  480. INIT_LIST_HEAD(&used);
  481. INIT_LIST_HEAD(&free);
  482. ai->min_ec = UBI_MAX_ERASECOUNTER;
  483. fmsb = (struct ubi_fm_sb *)(fm_raw);
  484. ai->max_sqnum = fmsb->sqnum;
  485. fm_pos += sizeof(struct ubi_fm_sb);
  486. if (fm_pos >= fm_size)
  487. goto fail_bad;
  488. fmhdr = (struct ubi_fm_hdr *)(fm_raw + fm_pos);
  489. fm_pos += sizeof(*fmhdr);
  490. if (fm_pos >= fm_size)
  491. goto fail_bad;
  492. if (be32_to_cpu(fmhdr->magic) != UBI_FM_HDR_MAGIC) {
  493. ubi_err(ubi, "bad fastmap header magic: 0x%x, expected: 0x%x",
  494. be32_to_cpu(fmhdr->magic), UBI_FM_HDR_MAGIC);
  495. goto fail_bad;
  496. }
  497. fmpl = (struct ubi_fm_scan_pool *)(fm_raw + fm_pos);
  498. fm_pos += sizeof(*fmpl);
  499. if (fm_pos >= fm_size)
  500. goto fail_bad;
  501. if (be32_to_cpu(fmpl->magic) != UBI_FM_POOL_MAGIC) {
  502. ubi_err(ubi, "bad fastmap pool magic: 0x%x, expected: 0x%x",
  503. be32_to_cpu(fmpl->magic), UBI_FM_POOL_MAGIC);
  504. goto fail_bad;
  505. }
  506. fmpl_wl = (struct ubi_fm_scan_pool *)(fm_raw + fm_pos);
  507. fm_pos += sizeof(*fmpl_wl);
  508. if (fm_pos >= fm_size)
  509. goto fail_bad;
  510. if (be32_to_cpu(fmpl_wl->magic) != UBI_FM_POOL_MAGIC) {
  511. ubi_err(ubi, "bad fastmap WL pool magic: 0x%x, expected: 0x%x",
  512. be32_to_cpu(fmpl_wl->magic), UBI_FM_POOL_MAGIC);
  513. goto fail_bad;
  514. }
  515. pool_size = be16_to_cpu(fmpl->size);
  516. wl_pool_size = be16_to_cpu(fmpl_wl->size);
  517. fm->max_pool_size = be16_to_cpu(fmpl->max_size);
  518. fm->max_wl_pool_size = be16_to_cpu(fmpl_wl->max_size);
  519. if (pool_size > UBI_FM_MAX_POOL_SIZE || pool_size < 0) {
  520. ubi_err(ubi, "bad pool size: %i", pool_size);
  521. goto fail_bad;
  522. }
  523. if (wl_pool_size > UBI_FM_MAX_POOL_SIZE || wl_pool_size < 0) {
  524. ubi_err(ubi, "bad WL pool size: %i", wl_pool_size);
  525. goto fail_bad;
  526. }
  527. if (fm->max_pool_size > UBI_FM_MAX_POOL_SIZE ||
  528. fm->max_pool_size < 0) {
  529. ubi_err(ubi, "bad maximal pool size: %i", fm->max_pool_size);
  530. goto fail_bad;
  531. }
  532. if (fm->max_wl_pool_size > UBI_FM_MAX_POOL_SIZE ||
  533. fm->max_wl_pool_size < 0) {
  534. ubi_err(ubi, "bad maximal WL pool size: %i",
  535. fm->max_wl_pool_size);
  536. goto fail_bad;
  537. }
  538. /* read EC values from free list */
  539. for (i = 0; i < be32_to_cpu(fmhdr->free_peb_count); i++) {
  540. fmec = (struct ubi_fm_ec *)(fm_raw + fm_pos);
  541. fm_pos += sizeof(*fmec);
  542. if (fm_pos >= fm_size)
  543. goto fail_bad;
  544. add_aeb(ai, &ai->free, be32_to_cpu(fmec->pnum),
  545. be32_to_cpu(fmec->ec), 0);
  546. }
  547. /* read EC values from used list */
  548. for (i = 0; i < be32_to_cpu(fmhdr->used_peb_count); i++) {
  549. fmec = (struct ubi_fm_ec *)(fm_raw + fm_pos);
  550. fm_pos += sizeof(*fmec);
  551. if (fm_pos >= fm_size)
  552. goto fail_bad;
  553. add_aeb(ai, &used, be32_to_cpu(fmec->pnum),
  554. be32_to_cpu(fmec->ec), 0);
  555. }
  556. /* read EC values from scrub list */
  557. for (i = 0; i < be32_to_cpu(fmhdr->scrub_peb_count); i++) {
  558. fmec = (struct ubi_fm_ec *)(fm_raw + fm_pos);
  559. fm_pos += sizeof(*fmec);
  560. if (fm_pos >= fm_size)
  561. goto fail_bad;
  562. add_aeb(ai, &used, be32_to_cpu(fmec->pnum),
  563. be32_to_cpu(fmec->ec), 1);
  564. }
  565. /* read EC values from erase list */
  566. for (i = 0; i < be32_to_cpu(fmhdr->erase_peb_count); i++) {
  567. fmec = (struct ubi_fm_ec *)(fm_raw + fm_pos);
  568. fm_pos += sizeof(*fmec);
  569. if (fm_pos >= fm_size)
  570. goto fail_bad;
  571. add_aeb(ai, &ai->erase, be32_to_cpu(fmec->pnum),
  572. be32_to_cpu(fmec->ec), 1);
  573. }
  574. ai->mean_ec = div_u64(ai->ec_sum, ai->ec_count);
  575. ai->bad_peb_count = be32_to_cpu(fmhdr->bad_peb_count);
  576. /* Iterate over all volumes and read their EBA table */
  577. for (i = 0; i < be32_to_cpu(fmhdr->vol_count); i++) {
  578. fmvhdr = (struct ubi_fm_volhdr *)(fm_raw + fm_pos);
  579. fm_pos += sizeof(*fmvhdr);
  580. if (fm_pos >= fm_size)
  581. goto fail_bad;
  582. if (be32_to_cpu(fmvhdr->magic) != UBI_FM_VHDR_MAGIC) {
  583. ubi_err(ubi, "bad fastmap vol header magic: 0x%x, expected: 0x%x",
  584. be32_to_cpu(fmvhdr->magic), UBI_FM_VHDR_MAGIC);
  585. goto fail_bad;
  586. }
  587. av = add_vol(ai, be32_to_cpu(fmvhdr->vol_id),
  588. be32_to_cpu(fmvhdr->used_ebs),
  589. be32_to_cpu(fmvhdr->data_pad),
  590. fmvhdr->vol_type,
  591. be32_to_cpu(fmvhdr->last_eb_bytes));
  592. if (IS_ERR(av)) {
  593. if (PTR_ERR(av) == -EEXIST)
  594. ubi_err(ubi, "volume (ID %i) already exists",
  595. fmvhdr->vol_id);
  596. goto fail_bad;
  597. }
  598. ai->vols_found++;
  599. if (ai->highest_vol_id < be32_to_cpu(fmvhdr->vol_id))
  600. ai->highest_vol_id = be32_to_cpu(fmvhdr->vol_id);
  601. fm_eba = (struct ubi_fm_eba *)(fm_raw + fm_pos);
  602. fm_pos += sizeof(*fm_eba);
  603. fm_pos += (sizeof(__be32) * be32_to_cpu(fm_eba->reserved_pebs));
  604. if (fm_pos >= fm_size)
  605. goto fail_bad;
  606. if (be32_to_cpu(fm_eba->magic) != UBI_FM_EBA_MAGIC) {
  607. ubi_err(ubi, "bad fastmap EBA header magic: 0x%x, expected: 0x%x",
  608. be32_to_cpu(fm_eba->magic), UBI_FM_EBA_MAGIC);
  609. goto fail_bad;
  610. }
  611. for (j = 0; j < be32_to_cpu(fm_eba->reserved_pebs); j++) {
  612. int pnum = be32_to_cpu(fm_eba->pnum[j]);
  613. if (pnum < 0)
  614. continue;
  615. aeb = NULL;
  616. list_for_each_entry(tmp_aeb, &used, u.list) {
  617. if (tmp_aeb->pnum == pnum) {
  618. aeb = tmp_aeb;
  619. break;
  620. }
  621. }
  622. if (!aeb) {
  623. ubi_err(ubi, "PEB %i is in EBA but not in used list", pnum);
  624. goto fail_bad;
  625. }
  626. aeb->lnum = j;
  627. if (av->highest_lnum <= aeb->lnum)
  628. av->highest_lnum = aeb->lnum;
  629. assign_aeb_to_av(ai, aeb, av);
  630. dbg_bld("inserting PEB:%i (LEB %i) to vol %i",
  631. aeb->pnum, aeb->lnum, av->vol_id);
  632. }
  633. }
  634. ret = scan_pool(ubi, ai, fmpl->pebs, pool_size, &max_sqnum, &free);
  635. if (ret)
  636. goto fail;
  637. ret = scan_pool(ubi, ai, fmpl_wl->pebs, wl_pool_size, &max_sqnum, &free);
  638. if (ret)
  639. goto fail;
  640. if (max_sqnum > ai->max_sqnum)
  641. ai->max_sqnum = max_sqnum;
  642. list_for_each_entry_safe(tmp_aeb, _tmp_aeb, &free, u.list)
  643. list_move_tail(&tmp_aeb->u.list, &ai->free);
  644. list_for_each_entry_safe(tmp_aeb, _tmp_aeb, &used, u.list)
  645. list_move_tail(&tmp_aeb->u.list, &ai->erase);
  646. ubi_assert(list_empty(&free));
  647. /*
  648. * If fastmap is leaking PEBs (must not happen), raise a
  649. * fat warning and fall back to scanning mode.
  650. * We do this here because in ubi_wl_init() it's too late
  651. * and we cannot fall back to scanning.
  652. */
  653. if (WARN_ON(count_fastmap_pebs(ai) != ubi->peb_count -
  654. ai->bad_peb_count - fm->used_blocks))
  655. goto fail_bad;
  656. return 0;
  657. fail_bad:
  658. ret = UBI_BAD_FASTMAP;
  659. fail:
  660. list_for_each_entry_safe(tmp_aeb, _tmp_aeb, &used, u.list) {
  661. list_del(&tmp_aeb->u.list);
  662. ubi_free_aeb(ai, tmp_aeb);
  663. }
  664. list_for_each_entry_safe(tmp_aeb, _tmp_aeb, &free, u.list) {
  665. list_del(&tmp_aeb->u.list);
  666. ubi_free_aeb(ai, tmp_aeb);
  667. }
  668. return ret;
  669. }
  670. /**
  671. * find_fm_anchor - find the most recent Fastmap superblock (anchor)
  672. * @ai: UBI attach info to be filled
  673. */
  674. static int find_fm_anchor(struct ubi_attach_info *ai)
  675. {
  676. int ret = -1;
  677. struct ubi_ainf_peb *aeb;
  678. unsigned long long max_sqnum = 0;
  679. list_for_each_entry(aeb, &ai->fastmap, u.list) {
  680. if (aeb->vol_id == UBI_FM_SB_VOLUME_ID && aeb->sqnum > max_sqnum) {
  681. max_sqnum = aeb->sqnum;
  682. ret = aeb->pnum;
  683. }
  684. }
  685. return ret;
  686. }
  687. static struct ubi_ainf_peb *clone_aeb(struct ubi_attach_info *ai,
  688. struct ubi_ainf_peb *old)
  689. {
  690. struct ubi_ainf_peb *new;
  691. new = ubi_alloc_aeb(ai, old->pnum, old->ec);
  692. if (!new)
  693. return NULL;
  694. new->vol_id = old->vol_id;
  695. new->sqnum = old->sqnum;
  696. new->lnum = old->lnum;
  697. new->scrub = old->scrub;
  698. new->copy_flag = old->copy_flag;
  699. return new;
  700. }
  701. /**
  702. * ubi_scan_fastmap - scan the fastmap.
  703. * @ubi: UBI device object
  704. * @ai: UBI attach info to be filled
  705. * @scan_ai: UBI attach info from the first 64 PEBs,
  706. * used to find the most recent Fastmap data structure
  707. *
  708. * Returns 0 on success, UBI_NO_FASTMAP if no fastmap was found,
  709. * UBI_BAD_FASTMAP if one was found but is not usable.
  710. * < 0 indicates an internal error.
  711. */
  712. int ubi_scan_fastmap(struct ubi_device *ubi, struct ubi_attach_info *ai,
  713. struct ubi_attach_info *scan_ai)
  714. {
  715. struct ubi_fm_sb *fmsb, *fmsb2;
  716. struct ubi_vid_io_buf *vb;
  717. struct ubi_vid_hdr *vh;
  718. struct ubi_ec_hdr *ech;
  719. struct ubi_fastmap_layout *fm;
  720. struct ubi_ainf_peb *aeb;
  721. int i, used_blocks, pnum, fm_anchor, ret = 0;
  722. size_t fm_size;
  723. __be32 crc, tmp_crc;
  724. unsigned long long sqnum = 0;
  725. fm_anchor = find_fm_anchor(scan_ai);
  726. if (fm_anchor < 0)
  727. return UBI_NO_FASTMAP;
  728. /* Copy all (possible) fastmap blocks into our new attach structure. */
  729. list_for_each_entry(aeb, &scan_ai->fastmap, u.list) {
  730. struct ubi_ainf_peb *new;
  731. new = clone_aeb(ai, aeb);
  732. if (!new)
  733. return -ENOMEM;
  734. list_add(&new->u.list, &ai->fastmap);
  735. }
  736. down_write(&ubi->fm_protect);
  737. memset(ubi->fm_buf, 0, ubi->fm_size);
  738. fmsb = kmalloc(sizeof(*fmsb), GFP_KERNEL);
  739. if (!fmsb) {
  740. ret = -ENOMEM;
  741. goto out;
  742. }
  743. fm = kzalloc(sizeof(*fm), GFP_KERNEL);
  744. if (!fm) {
  745. ret = -ENOMEM;
  746. kfree(fmsb);
  747. goto out;
  748. }
  749. ret = ubi_io_read_data(ubi, fmsb, fm_anchor, 0, sizeof(*fmsb));
  750. if (ret && ret != UBI_IO_BITFLIPS)
  751. goto free_fm_sb;
  752. else if (ret == UBI_IO_BITFLIPS)
  753. fm->to_be_tortured[0] = 1;
  754. if (be32_to_cpu(fmsb->magic) != UBI_FM_SB_MAGIC) {
  755. ubi_err(ubi, "bad super block magic: 0x%x, expected: 0x%x",
  756. be32_to_cpu(fmsb->magic), UBI_FM_SB_MAGIC);
  757. ret = UBI_BAD_FASTMAP;
  758. goto free_fm_sb;
  759. }
  760. if (fmsb->version != UBI_FM_FMT_VERSION) {
  761. ubi_err(ubi, "bad fastmap version: %i, expected: %i",
  762. fmsb->version, UBI_FM_FMT_VERSION);
  763. ret = UBI_BAD_FASTMAP;
  764. goto free_fm_sb;
  765. }
  766. used_blocks = be32_to_cpu(fmsb->used_blocks);
  767. if (used_blocks > UBI_FM_MAX_BLOCKS || used_blocks < 1) {
  768. ubi_err(ubi, "number of fastmap blocks is invalid: %i",
  769. used_blocks);
  770. ret = UBI_BAD_FASTMAP;
  771. goto free_fm_sb;
  772. }
  773. fm_size = ubi->leb_size * used_blocks;
  774. if (fm_size != ubi->fm_size) {
  775. ubi_err(ubi, "bad fastmap size: %zi, expected: %zi",
  776. fm_size, ubi->fm_size);
  777. ret = UBI_BAD_FASTMAP;
  778. goto free_fm_sb;
  779. }
  780. ech = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);
  781. if (!ech) {
  782. ret = -ENOMEM;
  783. goto free_fm_sb;
  784. }
  785. vb = ubi_alloc_vid_buf(ubi, GFP_KERNEL);
  786. if (!vb) {
  787. ret = -ENOMEM;
  788. goto free_hdr;
  789. }
  790. vh = ubi_get_vid_hdr(vb);
  791. for (i = 0; i < used_blocks; i++) {
  792. int image_seq;
  793. pnum = be32_to_cpu(fmsb->block_loc[i]);
  794. if (ubi_io_is_bad(ubi, pnum)) {
  795. ret = UBI_BAD_FASTMAP;
  796. goto free_hdr;
  797. }
  798. if (i == 0 && pnum != fm_anchor) {
  799. ubi_err(ubi, "Fastmap anchor PEB mismatch: PEB: %i vs. %i",
  800. pnum, fm_anchor);
  801. ret = UBI_BAD_FASTMAP;
  802. goto free_hdr;
  803. }
  804. ret = ubi_io_read_ec_hdr(ubi, pnum, ech, 0);
  805. if (ret && ret != UBI_IO_BITFLIPS) {
  806. ubi_err(ubi, "unable to read fastmap block# %i EC (PEB: %i)",
  807. i, pnum);
  808. if (ret > 0)
  809. ret = UBI_BAD_FASTMAP;
  810. goto free_hdr;
  811. } else if (ret == UBI_IO_BITFLIPS)
  812. fm->to_be_tortured[i] = 1;
  813. image_seq = be32_to_cpu(ech->image_seq);
  814. if (!ubi->image_seq)
  815. ubi->image_seq = image_seq;
  816. /*
  817. * Older UBI implementations have image_seq set to zero, so
  818. * we shouldn't fail if image_seq == 0.
  819. */
  820. if (image_seq && (image_seq != ubi->image_seq)) {
  821. ubi_err(ubi, "wrong image seq:%d instead of %d",
  822. be32_to_cpu(ech->image_seq), ubi->image_seq);
  823. ret = UBI_BAD_FASTMAP;
  824. goto free_hdr;
  825. }
  826. ret = ubi_io_read_vid_hdr(ubi, pnum, vb, 0);
  827. if (ret && ret != UBI_IO_BITFLIPS) {
  828. ubi_err(ubi, "unable to read fastmap block# %i (PEB: %i)",
  829. i, pnum);
  830. goto free_hdr;
  831. }
  832. if (i == 0) {
  833. if (be32_to_cpu(vh->vol_id) != UBI_FM_SB_VOLUME_ID) {
  834. ubi_err(ubi, "bad fastmap anchor vol_id: 0x%x, expected: 0x%x",
  835. be32_to_cpu(vh->vol_id),
  836. UBI_FM_SB_VOLUME_ID);
  837. ret = UBI_BAD_FASTMAP;
  838. goto free_hdr;
  839. }
  840. } else {
  841. if (be32_to_cpu(vh->vol_id) != UBI_FM_DATA_VOLUME_ID) {
  842. ubi_err(ubi, "bad fastmap data vol_id: 0x%x, expected: 0x%x",
  843. be32_to_cpu(vh->vol_id),
  844. UBI_FM_DATA_VOLUME_ID);
  845. ret = UBI_BAD_FASTMAP;
  846. goto free_hdr;
  847. }
  848. }
  849. if (sqnum < be64_to_cpu(vh->sqnum))
  850. sqnum = be64_to_cpu(vh->sqnum);
  851. ret = ubi_io_read_data(ubi, ubi->fm_buf + (ubi->leb_size * i),
  852. pnum, 0, ubi->leb_size);
  853. if (ret && ret != UBI_IO_BITFLIPS) {
  854. ubi_err(ubi, "unable to read fastmap block# %i (PEB: %i, "
  855. "err: %i)", i, pnum, ret);
  856. goto free_hdr;
  857. }
  858. }
  859. kfree(fmsb);
  860. fmsb = NULL;
  861. fmsb2 = (struct ubi_fm_sb *)(ubi->fm_buf);
  862. tmp_crc = be32_to_cpu(fmsb2->data_crc);
  863. fmsb2->data_crc = 0;
  864. crc = crc32(UBI_CRC32_INIT, ubi->fm_buf, fm_size);
  865. if (crc != tmp_crc) {
  866. ubi_err(ubi, "fastmap data CRC is invalid");
  867. ubi_err(ubi, "CRC should be: 0x%x, calc: 0x%x",
  868. tmp_crc, crc);
  869. ret = UBI_BAD_FASTMAP;
  870. goto free_hdr;
  871. }
  872. fmsb2->sqnum = sqnum;
  873. fm->used_blocks = used_blocks;
  874. ret = ubi_attach_fastmap(ubi, ai, fm);
  875. if (ret) {
  876. if (ret > 0)
  877. ret = UBI_BAD_FASTMAP;
  878. goto free_hdr;
  879. }
  880. for (i = 0; i < used_blocks; i++) {
  881. struct ubi_wl_entry *e;
  882. e = kmem_cache_alloc(ubi_wl_entry_slab, GFP_KERNEL);
  883. if (!e) {
  884. while (i--)
  885. kmem_cache_free(ubi_wl_entry_slab, fm->e[i]);
  886. ret = -ENOMEM;
  887. goto free_hdr;
  888. }
  889. e->pnum = be32_to_cpu(fmsb2->block_loc[i]);
  890. e->ec = be32_to_cpu(fmsb2->block_ec[i]);
  891. fm->e[i] = e;
  892. }
  893. ubi->fm = fm;
  894. ubi->fm_pool.max_size = ubi->fm->max_pool_size;
  895. ubi->fm_wl_pool.max_size = ubi->fm->max_wl_pool_size;
  896. ubi_msg(ubi, "attached by fastmap");
  897. ubi_msg(ubi, "fastmap pool size: %d", ubi->fm_pool.max_size);
  898. ubi_msg(ubi, "fastmap WL pool size: %d",
  899. ubi->fm_wl_pool.max_size);
  900. ubi->fm_disabled = 0;
  901. ubi->fast_attach = 1;
  902. ubi_free_vid_buf(vb);
  903. kfree(ech);
  904. out:
  905. up_write(&ubi->fm_protect);
  906. if (ret == UBI_BAD_FASTMAP)
  907. ubi_err(ubi, "Attach by fastmap failed, doing a full scan!");
  908. return ret;
  909. free_hdr:
  910. ubi_free_vid_buf(vb);
  911. kfree(ech);
  912. free_fm_sb:
  913. kfree(fmsb);
  914. kfree(fm);
  915. goto out;
  916. }
  917. int ubi_fastmap_init_checkmap(struct ubi_volume *vol, int leb_count)
  918. {
  919. struct ubi_device *ubi = vol->ubi;
  920. if (!ubi->fast_attach)
  921. return 0;
  922. vol->checkmap = kcalloc(BITS_TO_LONGS(leb_count), sizeof(unsigned long),
  923. GFP_KERNEL);
  924. if (!vol->checkmap)
  925. return -ENOMEM;
  926. return 0;
  927. }
  928. void ubi_fastmap_destroy_checkmap(struct ubi_volume *vol)
  929. {
  930. kfree(vol->checkmap);
  931. }
  932. /**
  933. * ubi_write_fastmap - writes a fastmap.
  934. * @ubi: UBI device object
  935. * @new_fm: the to be written fastmap
  936. *
  937. * Returns 0 on success, < 0 indicates an internal error.
  938. */
  939. static int ubi_write_fastmap(struct ubi_device *ubi,
  940. struct ubi_fastmap_layout *new_fm)
  941. {
  942. size_t fm_pos = 0;
  943. void *fm_raw;
  944. struct ubi_fm_sb *fmsb;
  945. struct ubi_fm_hdr *fmh;
  946. struct ubi_fm_scan_pool *fmpl, *fmpl_wl;
  947. struct ubi_fm_ec *fec;
  948. struct ubi_fm_volhdr *fvh;
  949. struct ubi_fm_eba *feba;
  950. struct ubi_wl_entry *wl_e;
  951. struct ubi_volume *vol;
  952. struct ubi_vid_io_buf *avbuf, *dvbuf;
  953. struct ubi_vid_hdr *avhdr, *dvhdr;
  954. struct ubi_work *ubi_wrk;
  955. struct rb_node *tmp_rb;
  956. int ret, i, j, free_peb_count, used_peb_count, vol_count;
  957. int scrub_peb_count, erase_peb_count;
  958. unsigned long *seen_pebs = NULL;
  959. fm_raw = ubi->fm_buf;
  960. memset(ubi->fm_buf, 0, ubi->fm_size);
  961. avbuf = new_fm_vbuf(ubi, UBI_FM_SB_VOLUME_ID);
  962. if (!avbuf) {
  963. ret = -ENOMEM;
  964. goto out;
  965. }
  966. dvbuf = new_fm_vbuf(ubi, UBI_FM_DATA_VOLUME_ID);
  967. if (!dvbuf) {
  968. ret = -ENOMEM;
  969. goto out_kfree;
  970. }
  971. avhdr = ubi_get_vid_hdr(avbuf);
  972. dvhdr = ubi_get_vid_hdr(dvbuf);
  973. seen_pebs = init_seen(ubi);
  974. if (IS_ERR(seen_pebs)) {
  975. ret = PTR_ERR(seen_pebs);
  976. goto out_kfree;
  977. }
  978. spin_lock(&ubi->volumes_lock);
  979. spin_lock(&ubi->wl_lock);
  980. fmsb = (struct ubi_fm_sb *)fm_raw;
  981. fm_pos += sizeof(*fmsb);
  982. ubi_assert(fm_pos <= ubi->fm_size);
  983. fmh = (struct ubi_fm_hdr *)(fm_raw + fm_pos);
  984. fm_pos += sizeof(*fmh);
  985. ubi_assert(fm_pos <= ubi->fm_size);
  986. fmsb->magic = cpu_to_be32(UBI_FM_SB_MAGIC);
  987. fmsb->version = UBI_FM_FMT_VERSION;
  988. fmsb->used_blocks = cpu_to_be32(new_fm->used_blocks);
  989. /* the max sqnum will be filled in while *reading* the fastmap */
  990. fmsb->sqnum = 0;
  991. fmh->magic = cpu_to_be32(UBI_FM_HDR_MAGIC);
  992. free_peb_count = 0;
  993. used_peb_count = 0;
  994. scrub_peb_count = 0;
  995. erase_peb_count = 0;
  996. vol_count = 0;
  997. fmpl = (struct ubi_fm_scan_pool *)(fm_raw + fm_pos);
  998. fm_pos += sizeof(*fmpl);
  999. fmpl->magic = cpu_to_be32(UBI_FM_POOL_MAGIC);
  1000. fmpl->size = cpu_to_be16(ubi->fm_pool.size);
  1001. fmpl->max_size = cpu_to_be16(ubi->fm_pool.max_size);
  1002. for (i = 0; i < ubi->fm_pool.size; i++) {
  1003. fmpl->pebs[i] = cpu_to_be32(ubi->fm_pool.pebs[i]);
  1004. set_seen(ubi, ubi->fm_pool.pebs[i], seen_pebs);
  1005. }
  1006. fmpl_wl = (struct ubi_fm_scan_pool *)(fm_raw + fm_pos);
  1007. fm_pos += sizeof(*fmpl_wl);
  1008. fmpl_wl->magic = cpu_to_be32(UBI_FM_POOL_MAGIC);
  1009. fmpl_wl->size = cpu_to_be16(ubi->fm_wl_pool.size);
  1010. fmpl_wl->max_size = cpu_to_be16(ubi->fm_wl_pool.max_size);
  1011. for (i = 0; i < ubi->fm_wl_pool.size; i++) {
  1012. fmpl_wl->pebs[i] = cpu_to_be32(ubi->fm_wl_pool.pebs[i]);
  1013. set_seen(ubi, ubi->fm_wl_pool.pebs[i], seen_pebs);
  1014. }
  1015. ubi_for_each_free_peb(ubi, wl_e, tmp_rb) {
  1016. fec = (struct ubi_fm_ec *)(fm_raw + fm_pos);
  1017. fec->pnum = cpu_to_be32(wl_e->pnum);
  1018. set_seen(ubi, wl_e->pnum, seen_pebs);
  1019. fec->ec = cpu_to_be32(wl_e->ec);
  1020. free_peb_count++;
  1021. fm_pos += sizeof(*fec);
  1022. ubi_assert(fm_pos <= ubi->fm_size);
  1023. }
  1024. fmh->free_peb_count = cpu_to_be32(free_peb_count);
  1025. ubi_for_each_used_peb(ubi, wl_e, tmp_rb) {
  1026. fec = (struct ubi_fm_ec *)(fm_raw + fm_pos);
  1027. fec->pnum = cpu_to_be32(wl_e->pnum);
  1028. set_seen(ubi, wl_e->pnum, seen_pebs);
  1029. fec->ec = cpu_to_be32(wl_e->ec);
  1030. used_peb_count++;
  1031. fm_pos += sizeof(*fec);
  1032. ubi_assert(fm_pos <= ubi->fm_size);
  1033. }
  1034. ubi_for_each_protected_peb(ubi, i, wl_e) {
  1035. fec = (struct ubi_fm_ec *)(fm_raw + fm_pos);
  1036. fec->pnum = cpu_to_be32(wl_e->pnum);
  1037. set_seen(ubi, wl_e->pnum, seen_pebs);
  1038. fec->ec = cpu_to_be32(wl_e->ec);
  1039. used_peb_count++;
  1040. fm_pos += sizeof(*fec);
  1041. ubi_assert(fm_pos <= ubi->fm_size);
  1042. }
  1043. fmh->used_peb_count = cpu_to_be32(used_peb_count);
  1044. ubi_for_each_scrub_peb(ubi, wl_e, tmp_rb) {
  1045. fec = (struct ubi_fm_ec *)(fm_raw + fm_pos);
  1046. fec->pnum = cpu_to_be32(wl_e->pnum);
  1047. set_seen(ubi, wl_e->pnum, seen_pebs);
  1048. fec->ec = cpu_to_be32(wl_e->ec);
  1049. scrub_peb_count++;
  1050. fm_pos += sizeof(*fec);
  1051. ubi_assert(fm_pos <= ubi->fm_size);
  1052. }
  1053. fmh->scrub_peb_count = cpu_to_be32(scrub_peb_count);
  1054. list_for_each_entry(ubi_wrk, &ubi->works, list) {
  1055. if (ubi_is_erase_work(ubi_wrk)) {
  1056. wl_e = ubi_wrk->e;
  1057. ubi_assert(wl_e);
  1058. fec = (struct ubi_fm_ec *)(fm_raw + fm_pos);
  1059. fec->pnum = cpu_to_be32(wl_e->pnum);
  1060. set_seen(ubi, wl_e->pnum, seen_pebs);
  1061. fec->ec = cpu_to_be32(wl_e->ec);
  1062. erase_peb_count++;
  1063. fm_pos += sizeof(*fec);
  1064. ubi_assert(fm_pos <= ubi->fm_size);
  1065. }
  1066. }
  1067. fmh->erase_peb_count = cpu_to_be32(erase_peb_count);
  1068. for (i = 0; i < UBI_MAX_VOLUMES + UBI_INT_VOL_COUNT; i++) {
  1069. vol = ubi->volumes[i];
  1070. if (!vol)
  1071. continue;
  1072. vol_count++;
  1073. fvh = (struct ubi_fm_volhdr *)(fm_raw + fm_pos);
  1074. fm_pos += sizeof(*fvh);
  1075. ubi_assert(fm_pos <= ubi->fm_size);
  1076. fvh->magic = cpu_to_be32(UBI_FM_VHDR_MAGIC);
  1077. fvh->vol_id = cpu_to_be32(vol->vol_id);
  1078. fvh->vol_type = vol->vol_type;
  1079. fvh->used_ebs = cpu_to_be32(vol->used_ebs);
  1080. fvh->data_pad = cpu_to_be32(vol->data_pad);
  1081. fvh->last_eb_bytes = cpu_to_be32(vol->last_eb_bytes);
  1082. ubi_assert(vol->vol_type == UBI_DYNAMIC_VOLUME ||
  1083. vol->vol_type == UBI_STATIC_VOLUME);
  1084. feba = (struct ubi_fm_eba *)(fm_raw + fm_pos);
  1085. fm_pos += sizeof(*feba) + (sizeof(__be32) * vol->reserved_pebs);
  1086. ubi_assert(fm_pos <= ubi->fm_size);
  1087. for (j = 0; j < vol->reserved_pebs; j++) {
  1088. struct ubi_eba_leb_desc ldesc;
  1089. ubi_eba_get_ldesc(vol, j, &ldesc);
  1090. feba->pnum[j] = cpu_to_be32(ldesc.pnum);
  1091. }
  1092. feba->reserved_pebs = cpu_to_be32(j);
  1093. feba->magic = cpu_to_be32(UBI_FM_EBA_MAGIC);
  1094. }
  1095. fmh->vol_count = cpu_to_be32(vol_count);
  1096. fmh->bad_peb_count = cpu_to_be32(ubi->bad_peb_count);
  1097. avhdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi));
  1098. avhdr->lnum = 0;
  1099. spin_unlock(&ubi->wl_lock);
  1100. spin_unlock(&ubi->volumes_lock);
  1101. dbg_bld("writing fastmap SB to PEB %i", new_fm->e[0]->pnum);
  1102. ret = ubi_io_write_vid_hdr(ubi, new_fm->e[0]->pnum, avbuf);
  1103. if (ret) {
  1104. ubi_err(ubi, "unable to write vid_hdr to fastmap SB!");
  1105. goto out_kfree;
  1106. }
  1107. for (i = 0; i < new_fm->used_blocks; i++) {
  1108. fmsb->block_loc[i] = cpu_to_be32(new_fm->e[i]->pnum);
  1109. set_seen(ubi, new_fm->e[i]->pnum, seen_pebs);
  1110. fmsb->block_ec[i] = cpu_to_be32(new_fm->e[i]->ec);
  1111. }
  1112. fmsb->data_crc = 0;
  1113. fmsb->data_crc = cpu_to_be32(crc32(UBI_CRC32_INIT, fm_raw,
  1114. ubi->fm_size));
  1115. for (i = 1; i < new_fm->used_blocks; i++) {
  1116. dvhdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi));
  1117. dvhdr->lnum = cpu_to_be32(i);
  1118. dbg_bld("writing fastmap data to PEB %i sqnum %llu",
  1119. new_fm->e[i]->pnum, be64_to_cpu(dvhdr->sqnum));
  1120. ret = ubi_io_write_vid_hdr(ubi, new_fm->e[i]->pnum, dvbuf);
  1121. if (ret) {
  1122. ubi_err(ubi, "unable to write vid_hdr to PEB %i!",
  1123. new_fm->e[i]->pnum);
  1124. goto out_kfree;
  1125. }
  1126. }
  1127. for (i = 0; i < new_fm->used_blocks; i++) {
  1128. ret = ubi_io_write_data(ubi, fm_raw + (i * ubi->leb_size),
  1129. new_fm->e[i]->pnum, 0, ubi->leb_size);
  1130. if (ret) {
  1131. ubi_err(ubi, "unable to write fastmap to PEB %i!",
  1132. new_fm->e[i]->pnum);
  1133. goto out_kfree;
  1134. }
  1135. }
  1136. ubi_assert(new_fm);
  1137. ubi->fm = new_fm;
  1138. ret = self_check_seen(ubi, seen_pebs);
  1139. dbg_bld("fastmap written!");
  1140. out_kfree:
  1141. ubi_free_vid_buf(avbuf);
  1142. ubi_free_vid_buf(dvbuf);
  1143. free_seen(seen_pebs);
  1144. out:
  1145. return ret;
  1146. }
  1147. /**
  1148. * erase_block - Manually erase a PEB.
  1149. * @ubi: UBI device object
  1150. * @pnum: PEB to be erased
  1151. *
  1152. * Returns the new EC value on success, < 0 indicates an internal error.
  1153. */
  1154. static int erase_block(struct ubi_device *ubi, int pnum)
  1155. {
  1156. int ret;
  1157. struct ubi_ec_hdr *ec_hdr;
  1158. long long ec;
  1159. ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);
  1160. if (!ec_hdr)
  1161. return -ENOMEM;
  1162. ret = ubi_io_read_ec_hdr(ubi, pnum, ec_hdr, 0);
  1163. if (ret < 0)
  1164. goto out;
  1165. else if (ret && ret != UBI_IO_BITFLIPS) {
  1166. ret = -EINVAL;
  1167. goto out;
  1168. }
  1169. ret = ubi_io_sync_erase(ubi, pnum, 0);
  1170. if (ret < 0)
  1171. goto out;
  1172. ec = be64_to_cpu(ec_hdr->ec);
  1173. ec += ret;
  1174. if (ec > UBI_MAX_ERASECOUNTER) {
  1175. ret = -EINVAL;
  1176. goto out;
  1177. }
  1178. ec_hdr->ec = cpu_to_be64(ec);
  1179. ret = ubi_io_write_ec_hdr(ubi, pnum, ec_hdr);
  1180. if (ret < 0)
  1181. goto out;
  1182. ret = ec;
  1183. out:
  1184. kfree(ec_hdr);
  1185. return ret;
  1186. }
  1187. /**
  1188. * invalidate_fastmap - destroys a fastmap.
  1189. * @ubi: UBI device object
  1190. *
  1191. * This function ensures that upon next UBI attach a full scan
  1192. * is issued. We need this if UBI is about to write a new fastmap
  1193. * but is unable to do so. In this case we have two options:
  1194. * a) Make sure that the current fastmap will not be usued upon
  1195. * attach time and contine or b) fall back to RO mode to have the
  1196. * current fastmap in a valid state.
  1197. * Returns 0 on success, < 0 indicates an internal error.
  1198. */
  1199. static int invalidate_fastmap(struct ubi_device *ubi)
  1200. {
  1201. int ret;
  1202. struct ubi_fastmap_layout *fm;
  1203. struct ubi_wl_entry *e;
  1204. struct ubi_vid_io_buf *vb = NULL;
  1205. struct ubi_vid_hdr *vh;
  1206. if (!ubi->fm)
  1207. return 0;
  1208. ubi->fm = NULL;
  1209. ret = -ENOMEM;
  1210. fm = kzalloc(sizeof(*fm), GFP_KERNEL);
  1211. if (!fm)
  1212. goto out;
  1213. vb = new_fm_vbuf(ubi, UBI_FM_SB_VOLUME_ID);
  1214. if (!vb)
  1215. goto out_free_fm;
  1216. vh = ubi_get_vid_hdr(vb);
  1217. ret = -ENOSPC;
  1218. e = ubi_wl_get_fm_peb(ubi, 1);
  1219. if (!e)
  1220. goto out_free_fm;
  1221. /*
  1222. * Create fake fastmap such that UBI will fall back
  1223. * to scanning mode.
  1224. */
  1225. vh->sqnum = cpu_to_be64(ubi_next_sqnum(ubi));
  1226. ret = ubi_io_write_vid_hdr(ubi, e->pnum, vb);
  1227. if (ret < 0) {
  1228. ubi_wl_put_fm_peb(ubi, e, 0, 0);
  1229. goto out_free_fm;
  1230. }
  1231. fm->used_blocks = 1;
  1232. fm->e[0] = e;
  1233. ubi->fm = fm;
  1234. out:
  1235. ubi_free_vid_buf(vb);
  1236. return ret;
  1237. out_free_fm:
  1238. kfree(fm);
  1239. goto out;
  1240. }
  1241. /**
  1242. * return_fm_pebs - returns all PEBs used by a fastmap back to the
  1243. * WL sub-system.
  1244. * @ubi: UBI device object
  1245. * @fm: fastmap layout object
  1246. */
  1247. static void return_fm_pebs(struct ubi_device *ubi,
  1248. struct ubi_fastmap_layout *fm)
  1249. {
  1250. int i;
  1251. if (!fm)
  1252. return;
  1253. for (i = 0; i < fm->used_blocks; i++) {
  1254. if (fm->e[i]) {
  1255. ubi_wl_put_fm_peb(ubi, fm->e[i], i,
  1256. fm->to_be_tortured[i]);
  1257. fm->e[i] = NULL;
  1258. }
  1259. }
  1260. }
  1261. /**
  1262. * ubi_update_fastmap - will be called by UBI if a volume changes or
  1263. * a fastmap pool becomes full.
  1264. * @ubi: UBI device object
  1265. *
  1266. * Returns 0 on success, < 0 indicates an internal error.
  1267. */
  1268. int ubi_update_fastmap(struct ubi_device *ubi)
  1269. {
  1270. int ret, i, j;
  1271. struct ubi_fastmap_layout *new_fm, *old_fm;
  1272. struct ubi_wl_entry *tmp_e;
  1273. down_write(&ubi->fm_protect);
  1274. down_write(&ubi->work_sem);
  1275. down_write(&ubi->fm_eba_sem);
  1276. ubi_refill_pools(ubi);
  1277. if (ubi->ro_mode || ubi->fm_disabled) {
  1278. up_write(&ubi->fm_eba_sem);
  1279. up_write(&ubi->work_sem);
  1280. up_write(&ubi->fm_protect);
  1281. return 0;
  1282. }
  1283. ret = ubi_ensure_anchor_pebs(ubi);
  1284. if (ret) {
  1285. up_write(&ubi->fm_eba_sem);
  1286. up_write(&ubi->work_sem);
  1287. up_write(&ubi->fm_protect);
  1288. return ret;
  1289. }
  1290. new_fm = kzalloc(sizeof(*new_fm), GFP_KERNEL);
  1291. if (!new_fm) {
  1292. up_write(&ubi->fm_eba_sem);
  1293. up_write(&ubi->work_sem);
  1294. up_write(&ubi->fm_protect);
  1295. return -ENOMEM;
  1296. }
  1297. new_fm->used_blocks = ubi->fm_size / ubi->leb_size;
  1298. old_fm = ubi->fm;
  1299. ubi->fm = NULL;
  1300. if (new_fm->used_blocks > UBI_FM_MAX_BLOCKS) {
  1301. ubi_err(ubi, "fastmap too large");
  1302. ret = -ENOSPC;
  1303. goto err;
  1304. }
  1305. for (i = 1; i < new_fm->used_blocks; i++) {
  1306. spin_lock(&ubi->wl_lock);
  1307. tmp_e = ubi_wl_get_fm_peb(ubi, 0);
  1308. spin_unlock(&ubi->wl_lock);
  1309. if (!tmp_e) {
  1310. if (old_fm && old_fm->e[i]) {
  1311. ret = erase_block(ubi, old_fm->e[i]->pnum);
  1312. if (ret < 0) {
  1313. ubi_err(ubi, "could not erase old fastmap PEB");
  1314. for (j = 1; j < i; j++) {
  1315. ubi_wl_put_fm_peb(ubi, new_fm->e[j],
  1316. j, 0);
  1317. new_fm->e[j] = NULL;
  1318. }
  1319. goto err;
  1320. }
  1321. new_fm->e[i] = old_fm->e[i];
  1322. old_fm->e[i] = NULL;
  1323. } else {
  1324. ubi_err(ubi, "could not get any free erase block");
  1325. for (j = 1; j < i; j++) {
  1326. ubi_wl_put_fm_peb(ubi, new_fm->e[j], j, 0);
  1327. new_fm->e[j] = NULL;
  1328. }
  1329. ret = -ENOSPC;
  1330. goto err;
  1331. }
  1332. } else {
  1333. new_fm->e[i] = tmp_e;
  1334. if (old_fm && old_fm->e[i]) {
  1335. ubi_wl_put_fm_peb(ubi, old_fm->e[i], i,
  1336. old_fm->to_be_tortured[i]);
  1337. old_fm->e[i] = NULL;
  1338. }
  1339. }
  1340. }
  1341. /* Old fastmap is larger than the new one */
  1342. if (old_fm && new_fm->used_blocks < old_fm->used_blocks) {
  1343. for (i = new_fm->used_blocks; i < old_fm->used_blocks; i++) {
  1344. ubi_wl_put_fm_peb(ubi, old_fm->e[i], i,
  1345. old_fm->to_be_tortured[i]);
  1346. old_fm->e[i] = NULL;
  1347. }
  1348. }
  1349. spin_lock(&ubi->wl_lock);
  1350. tmp_e = ubi_wl_get_fm_peb(ubi, 1);
  1351. spin_unlock(&ubi->wl_lock);
  1352. if (old_fm) {
  1353. /* no fresh anchor PEB was found, reuse the old one */
  1354. if (!tmp_e) {
  1355. ret = erase_block(ubi, old_fm->e[0]->pnum);
  1356. if (ret < 0) {
  1357. ubi_err(ubi, "could not erase old anchor PEB");
  1358. for (i = 1; i < new_fm->used_blocks; i++) {
  1359. ubi_wl_put_fm_peb(ubi, new_fm->e[i],
  1360. i, 0);
  1361. new_fm->e[i] = NULL;
  1362. }
  1363. goto err;
  1364. }
  1365. new_fm->e[0] = old_fm->e[0];
  1366. new_fm->e[0]->ec = ret;
  1367. old_fm->e[0] = NULL;
  1368. } else {
  1369. /* we've got a new anchor PEB, return the old one */
  1370. ubi_wl_put_fm_peb(ubi, old_fm->e[0], 0,
  1371. old_fm->to_be_tortured[0]);
  1372. new_fm->e[0] = tmp_e;
  1373. old_fm->e[0] = NULL;
  1374. }
  1375. } else {
  1376. if (!tmp_e) {
  1377. ubi_err(ubi, "could not find any anchor PEB");
  1378. for (i = 1; i < new_fm->used_blocks; i++) {
  1379. ubi_wl_put_fm_peb(ubi, new_fm->e[i], i, 0);
  1380. new_fm->e[i] = NULL;
  1381. }
  1382. ret = -ENOSPC;
  1383. goto err;
  1384. }
  1385. new_fm->e[0] = tmp_e;
  1386. }
  1387. ret = ubi_write_fastmap(ubi, new_fm);
  1388. if (ret)
  1389. goto err;
  1390. out_unlock:
  1391. up_write(&ubi->fm_eba_sem);
  1392. up_write(&ubi->work_sem);
  1393. up_write(&ubi->fm_protect);
  1394. kfree(old_fm);
  1395. return ret;
  1396. err:
  1397. ubi_warn(ubi, "Unable to write new fastmap, err=%i", ret);
  1398. ret = invalidate_fastmap(ubi);
  1399. if (ret < 0) {
  1400. ubi_err(ubi, "Unable to invalidate current fastmap!");
  1401. ubi_ro_mode(ubi);
  1402. } else {
  1403. return_fm_pebs(ubi, old_fm);
  1404. return_fm_pebs(ubi, new_fm);
  1405. ret = 0;
  1406. }
  1407. kfree(new_fm);
  1408. goto out_unlock;
  1409. }