1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2012 Linutronix GmbH 4 * Copyright (c) 2014 sigma star gmbh 5 * Author: Richard Weinberger <richard@nod.at> 6 */ 7 8 /** 9 * update_fastmap_work_fn - calls ubi_update_fastmap from a work queue 10 * @wrk: the work description object 11 */ 12 static void update_fastmap_work_fn(struct work_struct *wrk) 13 { 14 struct ubi_device *ubi = container_of(wrk, struct ubi_device, fm_work); 15 16 ubi_update_fastmap(ubi); 17 spin_lock(&ubi->wl_lock); 18 ubi->fm_work_scheduled = 0; 19 spin_unlock(&ubi->wl_lock); 20 } 21 22 /** 23 * find_anchor_wl_entry - find wear-leveling entry to used as anchor PEB. 24 * @root: the RB-tree where to look for 25 */ 26 static struct ubi_wl_entry *find_anchor_wl_entry(struct rb_root *root) 27 { 28 struct rb_node *p; 29 struct ubi_wl_entry *e, *victim = NULL; 30 int max_ec = UBI_MAX_ERASECOUNTER; 31 32 ubi_rb_for_each_entry(p, e, root, u.rb) { 33 if (e->pnum < UBI_FM_MAX_START && e->ec < max_ec) { 34 victim = e; 35 max_ec = e->ec; 36 } 37 } 38 39 return victim; 40 } 41 42 /** 43 * return_unused_pool_pebs - returns unused PEB to the free tree. 44 * @ubi: UBI device description object 45 * @pool: fastmap pool description object 46 */ 47 static void return_unused_pool_pebs(struct ubi_device *ubi, 48 struct ubi_fm_pool *pool) 49 { 50 int i; 51 struct ubi_wl_entry *e; 52 53 for (i = pool->used; i < pool->size; i++) { 54 e = ubi->lookuptbl[pool->pebs[i]]; 55 wl_tree_add(e, &ubi->free); 56 ubi->free_count++; 57 } 58 } 59 60 /** 61 * ubi_wl_get_fm_peb - find a physical erase block with a given maximal number. 62 * @ubi: UBI device description object 63 * @anchor: This PEB will be used as anchor PEB by fastmap 64 * 65 * The function returns a physical erase block with a given maximal number 66 * and removes it from the wl subsystem. 67 * Must be called with wl_lock held! 68 */ 69 struct ubi_wl_entry *ubi_wl_get_fm_peb(struct ubi_device *ubi, int anchor) 70 { 71 struct ubi_wl_entry *e = NULL; 72 73 if (!ubi->free.rb_node || (ubi->free_count - ubi->beb_rsvd_pebs < 1)) 74 goto out; 75 76 if (anchor) 77 e = find_anchor_wl_entry(&ubi->free); 78 else 79 e = find_mean_wl_entry(ubi, &ubi->free); 80 81 if (!e) 82 goto out; 83 84 self_check_in_wl_tree(ubi, e, &ubi->free); 85 86 /* remove it from the free list, 87 * the wl subsystem does no longer know this erase block */ 88 rb_erase(&e->u.rb, &ubi->free); 89 ubi->free_count--; 90 out: 91 return e; 92 } 93 94 /** 95 * ubi_refill_pools - refills all fastmap PEB pools. 96 * @ubi: UBI device description object 97 */ 98 void ubi_refill_pools(struct ubi_device *ubi) 99 { 100 struct ubi_fm_pool *wl_pool = &ubi->fm_wl_pool; 101 struct ubi_fm_pool *pool = &ubi->fm_pool; 102 struct ubi_wl_entry *e; 103 int enough; 104 105 spin_lock(&ubi->wl_lock); 106 107 return_unused_pool_pebs(ubi, wl_pool); 108 return_unused_pool_pebs(ubi, pool); 109 110 wl_pool->size = 0; 111 pool->size = 0; 112 113 for (;;) { 114 enough = 0; 115 if (pool->size < pool->max_size) { 116 if (!ubi->free.rb_node) 117 break; 118 119 e = wl_get_wle(ubi); 120 if (!e) 121 break; 122 123 pool->pebs[pool->size] = e->pnum; 124 pool->size++; 125 } else 126 enough++; 127 128 if (wl_pool->size < wl_pool->max_size) { 129 if (!ubi->free.rb_node || 130 (ubi->free_count - ubi->beb_rsvd_pebs < 5)) 131 break; 132 133 e = find_wl_entry(ubi, &ubi->free, WL_FREE_MAX_DIFF); 134 self_check_in_wl_tree(ubi, e, &ubi->free); 135 rb_erase(&e->u.rb, &ubi->free); 136 ubi->free_count--; 137 138 wl_pool->pebs[wl_pool->size] = e->pnum; 139 wl_pool->size++; 140 } else 141 enough++; 142 143 if (enough == 2) 144 break; 145 } 146 147 wl_pool->used = 0; 148 pool->used = 0; 149 150 spin_unlock(&ubi->wl_lock); 151 } 152 153 /** 154 * produce_free_peb - produce a free physical eraseblock. 155 * @ubi: UBI device description object 156 * 157 * This function tries to make a free PEB by means of synchronous execution of 158 * pending works. This may be needed if, for example the background thread is 159 * disabled. Returns zero in case of success and a negative error code in case 160 * of failure. 161 */ 162 static int produce_free_peb(struct ubi_device *ubi) 163 { 164 int err; 165 166 while (!ubi->free.rb_node && ubi->works_count) { 167 dbg_wl("do one work synchronously"); 168 err = do_work(ubi); 169 170 if (err) 171 return err; 172 } 173 174 return 0; 175 } 176 177 /** 178 * ubi_wl_get_peb - get a physical eraseblock. 179 * @ubi: UBI device description object 180 * 181 * This function returns a physical eraseblock in case of success and a 182 * negative error code in case of failure. 183 * Returns with ubi->fm_eba_sem held in read mode! 184 */ 185 int ubi_wl_get_peb(struct ubi_device *ubi) 186 { 187 int ret, attempts = 0; 188 struct ubi_fm_pool *pool = &ubi->fm_pool; 189 struct ubi_fm_pool *wl_pool = &ubi->fm_wl_pool; 190 191 again: 192 down_read(&ubi->fm_eba_sem); 193 spin_lock(&ubi->wl_lock); 194 195 /* We check here also for the WL pool because at this point we can 196 * refill the WL pool synchronous. */ 197 if (pool->used == pool->size || wl_pool->used == wl_pool->size) { 198 spin_unlock(&ubi->wl_lock); 199 up_read(&ubi->fm_eba_sem); 200 ret = ubi_update_fastmap(ubi); 201 if (ret) { 202 ubi_msg(ubi, "Unable to write a new fastmap: %i", ret); 203 down_read(&ubi->fm_eba_sem); 204 return -ENOSPC; 205 } 206 down_read(&ubi->fm_eba_sem); 207 spin_lock(&ubi->wl_lock); 208 } 209 210 if (pool->used == pool->size) { 211 spin_unlock(&ubi->wl_lock); 212 attempts++; 213 if (attempts == 10) { 214 ubi_err(ubi, "Unable to get a free PEB from user WL pool"); 215 ret = -ENOSPC; 216 goto out; 217 } 218 up_read(&ubi->fm_eba_sem); 219 ret = produce_free_peb(ubi); 220 if (ret < 0) { 221 down_read(&ubi->fm_eba_sem); 222 goto out; 223 } 224 goto again; 225 } 226 227 ubi_assert(pool->used < pool->size); 228 ret = pool->pebs[pool->used++]; 229 prot_queue_add(ubi, ubi->lookuptbl[ret]); 230 spin_unlock(&ubi->wl_lock); 231 out: 232 return ret; 233 } 234 235 /* get_peb_for_wl - returns a PEB to be used internally by the WL sub-system. 236 * 237 * @ubi: UBI device description object 238 */ 239 static struct ubi_wl_entry *get_peb_for_wl(struct ubi_device *ubi) 240 { 241 struct ubi_fm_pool *pool = &ubi->fm_wl_pool; 242 int pnum; 243 244 ubi_assert(rwsem_is_locked(&ubi->fm_eba_sem)); 245 246 if (pool->used == pool->size) { 247 /* We cannot update the fastmap here because this 248 * function is called in atomic context. 249 * Let's fail here and refill/update it as soon as possible. */ 250 if (!ubi->fm_work_scheduled) { 251 ubi->fm_work_scheduled = 1; 252 schedule_work(&ubi->fm_work); 253 } 254 return NULL; 255 } 256 257 pnum = pool->pebs[pool->used++]; 258 return ubi->lookuptbl[pnum]; 259 } 260 261 /** 262 * ubi_ensure_anchor_pebs - schedule wear-leveling to produce an anchor PEB. 263 * @ubi: UBI device description object 264 */ 265 int ubi_ensure_anchor_pebs(struct ubi_device *ubi) 266 { 267 struct ubi_work *wrk; 268 struct ubi_wl_entry *anchor; 269 270 spin_lock(&ubi->wl_lock); 271 272 /* Do we already have an anchor? */ 273 if (ubi->fm_anchor) { 274 spin_unlock(&ubi->wl_lock); 275 return 0; 276 } 277 278 /* See if we can find an anchor PEB on the list of free PEBs */ 279 anchor = ubi_wl_get_fm_peb(ubi, 1); 280 if (anchor) { 281 ubi->fm_anchor = anchor; 282 spin_unlock(&ubi->wl_lock); 283 return 0; 284 } 285 286 /* No luck, trigger wear leveling to produce a new anchor PEB */ 287 ubi->fm_do_produce_anchor = 1; 288 if (ubi->wl_scheduled) { 289 spin_unlock(&ubi->wl_lock); 290 return 0; 291 } 292 ubi->wl_scheduled = 1; 293 spin_unlock(&ubi->wl_lock); 294 295 wrk = kmalloc(sizeof(struct ubi_work), GFP_NOFS); 296 if (!wrk) { 297 spin_lock(&ubi->wl_lock); 298 ubi->wl_scheduled = 0; 299 spin_unlock(&ubi->wl_lock); 300 return -ENOMEM; 301 } 302 303 wrk->func = &wear_leveling_worker; 304 __schedule_ubi_work(ubi, wrk); 305 return 0; 306 } 307 308 /** 309 * ubi_wl_put_fm_peb - returns a PEB used in a fastmap to the wear-leveling 310 * sub-system. 311 * see: ubi_wl_put_peb() 312 * 313 * @ubi: UBI device description object 314 * @fm_e: physical eraseblock to return 315 * @lnum: the last used logical eraseblock number for the PEB 316 * @torture: if this physical eraseblock has to be tortured 317 */ 318 int ubi_wl_put_fm_peb(struct ubi_device *ubi, struct ubi_wl_entry *fm_e, 319 int lnum, int torture) 320 { 321 struct ubi_wl_entry *e; 322 int vol_id, pnum = fm_e->pnum; 323 324 dbg_wl("PEB %d", pnum); 325 326 ubi_assert(pnum >= 0); 327 ubi_assert(pnum < ubi->peb_count); 328 329 spin_lock(&ubi->wl_lock); 330 e = ubi->lookuptbl[pnum]; 331 332 /* This can happen if we recovered from a fastmap the very 333 * first time and writing now a new one. In this case the wl system 334 * has never seen any PEB used by the original fastmap. 335 */ 336 if (!e) { 337 e = fm_e; 338 ubi_assert(e->ec >= 0); 339 ubi->lookuptbl[pnum] = e; 340 } 341 342 spin_unlock(&ubi->wl_lock); 343 344 vol_id = lnum ? UBI_FM_DATA_VOLUME_ID : UBI_FM_SB_VOLUME_ID; 345 return schedule_erase(ubi, e, vol_id, lnum, torture, true); 346 } 347 348 /** 349 * ubi_is_erase_work - checks whether a work is erase work. 350 * @wrk: The work object to be checked 351 */ 352 int ubi_is_erase_work(struct ubi_work *wrk) 353 { 354 return wrk->func == erase_worker; 355 } 356 357 static void ubi_fastmap_close(struct ubi_device *ubi) 358 { 359 int i; 360 361 return_unused_pool_pebs(ubi, &ubi->fm_pool); 362 return_unused_pool_pebs(ubi, &ubi->fm_wl_pool); 363 364 if (ubi->fm) { 365 for (i = 0; i < ubi->fm->used_blocks; i++) 366 kfree(ubi->fm->e[i]); 367 } 368 kfree(ubi->fm); 369 } 370 371 /** 372 * may_reserve_for_fm - tests whether a PEB shall be reserved for fastmap. 373 * See find_mean_wl_entry() 374 * 375 * @ubi: UBI device description object 376 * @e: physical eraseblock to return 377 * @root: RB tree to test against. 378 */ 379 static struct ubi_wl_entry *may_reserve_for_fm(struct ubi_device *ubi, 380 struct ubi_wl_entry *e, 381 struct rb_root *root) { 382 if (e && !ubi->fm_disabled && !ubi->fm && 383 e->pnum < UBI_FM_MAX_START) 384 e = rb_entry(rb_next(root->rb_node), 385 struct ubi_wl_entry, u.rb); 386 387 return e; 388 } 389