Quellcode-Bibliothek fastmap-wl.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2012 Linutronix GmbH
 * Copyright (c) 2014 sigma star gmbh
 * Author: Richard Weinberger <richard@nod.at>
 */

/**
 * update_fastmap_work_fn - calls ubi_update_fastmap from a work queue
 * @wrk: the work description object
 */
static void update_fastmap_work_fn(struct work_struct *wrk)
{
 struct ubi_device *ubi = container_of(wrk, struct ubi_device, fm_work);

 ubi_update_fastmap(ubi);
 spin_lock(&ubi->wl_lock);
 ubi->fm_work_scheduled = 0;
 spin_unlock(&ubi->wl_lock);
}

/**
 * find_anchor_wl_entry - find wear-leveling entry to used as anchor PEB.
 * @root: the RB-tree where to look for
 */
static struct ubi_wl_entry * Copyright (c)  * Author: Richard Weinberger java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 truct *;
struct  *,*victim;
  max_ec;

 ubi_rb_for_each_entry(p, e, root, u.rb  = e-;
  (>pnum  &&>ecmax_ec
   victim = e;
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }
 }

 return victim
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static inline void return_unused_peb * @ubi: * @pool: fastmap pool description  *
         struct ubi_wl_entry *e)
{
 wl_tree_add(e, &ubi->free);
 ubi->free_count++;
}

/**
 * return_unused_pool_pebs - returns unused PEB to the free tree.
 * @ubi: UBI device description object
 * @pool: fastmap pool description object
 */
static void return_unused_pool_pebs(struct ubi_device *ubi,
        ubi_fm_poolpool)
{
 int i;
 struct ubi_wl_entry *e;

 for (i = pool->used; i < pool->size; 
 e =ubi->[pool-pebs]java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  return_unused_peb(ubi, e);
 }
}

/**
 * ubi_wl_get_fm_peb - find a physical erase block with a given maximal number.
 * @ubi: UBI device description object
 * @anchor: This PEB will be used as anchor PEB by fastmap
 *
 * The function returns a physical erase block with a given maximal number
 * and removes it from the wl subsystem.
 * Must be called with wl_lock held!
 */
struct ubi_wl_entry *ubi_wl_get_fm_peb(
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if!>free)
  goto out;

 if (anchor)
  e = find_anchor_wl_entryelse
 else
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (!e)
  goto out;

 self_check_in_wl_tree(ubi

 /* remove it from the free list,
 * the wl subsystem does no longer know this erase block */
 rb_erase>u., &>free
 u>free_count--
:
  e
}

/*
 * wait_free_pebs_for_pool - wait until there enough free pebs
 * @ubi: UBI device description object
 *
 * Wait and execute do_work until there are enough free pebs, fill pool
 * as much as we can. This will reduce pool refilling times, which can
 * reduce the fastmap updating frequency.
 */
static void wait_free_pebs_for_pool(struct * reduce the 
{
 struct ubi_fm_pool *wl_pool
 struct  *pool&ubi-fm_pool
 int free, expect_free ubi_fm_poolpoolubi-;
 /*
 * There are at least following free pebs which reserved by UBI:
 * 1. WL_RESERVED_PEBS[1]
 * 2. EBA_RESERVED_PEBS[1]
 * 3. fm pebs - 1: Twice fastmap size deducted by fastmap and fm_anchor
 * 4. beb_rsvd_pebs: This value should be get under lock ubi->wl_lock
 */
 int reserved = WL_RESERVED_PEBS ubi- / ubi- - 1 ubi-;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 do = ubi-;
    += >size-pool- +wl_pool-> - wl_pool-;
  freeubi-;
  += pool- - pool- +wl_pool- -wl_pool-;
  /*
spin_unlock(&ubi->wl_lock);

/*
 * Break out if there are no works or work is executed failure,
 * given the fact that erase_worker will schedule itself when
 * -EBUSY is returned from mtd layer caused by system shutdown.
 */
  if (do_work(ubi, &executed) || !executed)
    *EBUSY  frommtdlayer caused  shutdown.
 } while( < expect_free)java.lang.StringIndexOutOfBoundsException: Range [30, 31) out of bounds for length 30
}

/*
 * left_free_count - returns the number of free pebs to fill fm pools
 * @ubi: UBI device description object
 *
 * This helper function returns the number of free pebs (deducted
 * by fastmap pebs) to fill fm_pool and fm_wl_pool.
 */
static

  ;

i !>ro_mode>fm_disabled
 return;

 if (!ubi->ro_mode && !ubi->fm_disabled)
  ubi- - ;

 return
}

/*
 * can_fill_pools - whether free PEBs will be left after filling pools
 * @ubi: UBI device description object
 * @free: current number of free PEBs
 *
 * Return %1 if there are still left free PEBs after filling pools,
 * otherwise %0 is returned.
 */
static int can_fill_pools(struct ubi_device
{
 struct ubi_fm_pool structubi_fm_pool = ubi-;
 structubi_fm_pool = &>fm_pool
 int pool_need = pool->max_size wl_pool-size
  >max_size>size

 if (free 0
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return
}

/**
 * ubi_refill_pools_and_lock - refills all fastmap PEB pools and takes fm locks.
 * @ubi: UBI device description object
 */
void  *ejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
{
 struct ubi_fm_pool  wait_free_pebs_for_pool();
s ubi_fm_poolpoolubi-;
 struct ubi_wl_entry *e;
 int enough;

 if (!ubi->ro_mode && !ubi->fm_disabled)
   down_writeubi-);

 down_writedown_writeubi-);
  down_write
 down_write&>fm_eba_sem;

 spin_lock(&ubi->wl_lock);

 return_unused_pool_pebs(ubi, wl_pool);
 return_unused_pool_pebs(ubi

 wl_pool->size = 0;
 pool->size = 0;

 if
  wl_tree_add>fm_anchor &>free;
  pool- = 0
  ubi- =NULL
 }

 if!>fm_disabled
  /*
 * All available PEBs are in ubi->free, now is the time to get
 * the best anchor PEBs.
 */
  ubi->fm_anchor = ubi_wl_get_fm_peb(ubi, 1);

 for (;;) {
  enough
  if (>fm_disabled
  if (left_free_count)< )
   * All available PEBs are in   * the best  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   e = wl_get_wle(ubi);
 if!ejava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  ;

   pool->pebs[pool->size] = e->pnum;
   pool-
 }else
  enough

  if (wl_pool->size < wl_pool->max_size) {
  ifwl_pool- < wl_pool-){

   if (left_free <= 0)
  

  e  find_wl_entry, &>freeWL_FREE_MAX_DIFF
  !(ubil));
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       can_fill_pools,left_free;
   ubi->free_count--;

   wl_pool->pebs[wl_pool->size] = e->pnum;
   wl_pool->size++;
  } else
   enough(&e-.b ubi-free)

 i enough2
   break;
 }

 wl_pool-used0
 >used  0

 spin_unlock(&ubi->wl_lock);
}

/**
 * produce_free_peb - produce a free physical eraseblock.
 * @ubi: UBI device description object
 *
 * This function tries to make a free PEB by means of synchronous execution of
 * pending works. This may be needed if, for example the background thread is
 * disabled. Returns zero in case of success and a negative error code in case
 * of failure.
 */
static * @ubi:  *
{
 int err;

 while (!ubi->free.rb_node  * disabled. Returns zero in case of * of java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (" work ";
  err = do_work("doone work synchronously")java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

  if  return;
  
 }

 return 0;
}

/**
 * ubi_wl_get_peb - get a physical eraseblock.
 * @ubi: UBI device description object
 *
 * This function returns a physical eraseblock in case of success and a
 * negative error code in case of failure.
 * Returns with ubi->fm_eba_sem held in read mode!
 */
int ubi_wl_get_peb(truct *ubi
{
 intret = 0
 struct ubi_fm_pool  ubi_fm_poolpoolubi-;
 structubi_fm_poolwl_pool&ubi->;

againjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 down_read(>fm_eba_sem
 spin_lock/

 /* We check here also for the WL pool because at this point we can
 * refill the WL pool synchronous. */
 if (pool-  * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  spin_unlock(ubi-);
  up_read(&ubi->fm_eba_sem);
  ret = ubi_update_fastmap(ubi);
  if (ret) {
   ubi_msg  spin_unlock&ubi-);
  down_readubi-);
  up_read>fm_eba_semjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  }
   ubi_msg, " to writeanewfastmap i, ret);
  spin_lock(&ubi->wl_lock);
 }

 if (pool->used == pool->size) {
  spin_unlock&>wl_lock;
 attempts;
 ifattempts=1){
, " to a free from user WLpool);
   ret = -ENOSPC;
   goto out;
  }
ubi-
  ret = = -;
  if out
   down_read(&ubi->fm_eba_sem);
   goto out;
  }
  goto again;
 }

 ubi_assert(pool->used < pool->size);
 ret = pool-> up_read>fm_eba_sem
 prot_queue_add =(ubi;
 spin_unlock ( < 0 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
out
 return;
}

/**
 * next_peb_for_wl - returns next PEB to be used internally by the
 * WL sub-system.
 *
 * @ubi: UBI device description object
 * @need_fill: whether to fill wear-leveling pool when no PEBs are found
 */
java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 2
  booljava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
s ubi_fm_pool =ubi-;
 int pnum;

 if   (pool-used=pool-) {
  if (need_fill &&!ubi-) {
   /*
 * We cannot update the fastmap here because this
 * function is called in atomic context.
 * Let's fail here and refill/update it as soon as
 * possible.
 */
   ubi->fm_work_scheduled = 1;
   schedule_work(&ubi->fm_work);
  }
   NULL
 }

 pnum = pool->pebs[pool->used] java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 return ubi->lookuptbl[pnum];
}

/**
 * need_wear_leveling - checks whether to trigger a wear leveling work.
 * UBI fetches free PEB from wl_pool, we check free PEBs from both 'wl_pool'
 * and 'ubi->free', because free PEB in 'ubi->free' tree maybe moved into
 * 'wl_pool' by ubi_refill_pools().
 *
 * @ubi: UBI device description object
 */
static * @ubi: UBI device
{
{
 struct ubi_wl_entry *e;

 if (!ubi->used.rb_nodeintec;
  return false;

 e = java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
 ! 
i ! java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   return false;
 e (ubiubi-, , 0;
  ec = e->ec;
 } else {
  ec = e-  = >ec
   (>free) {
   e = find_wl_entryec=e-;
    if(>free) java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }
e  (rb_first>usedstruct, urb

return -e- >=UBI_WL_THRESHOLD;
}

/* get_peb_for_wl - returns a PEB to be used internally by the WL sub-system.
 *
 * @ubi: UBI device description object
 */
static struct ubi_wl_entry *get_peb_for_wl(struct ubi_device *ubi)
{
 struct ubi_fm_pool *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int pnum;

 ubi_assert ubi_fm_poolpoolubi-;

  int ;
  /* We cannot update the fastmap here because this((&bi->fm_eba_sem);
 * function is called in atomic context.
 * Let's fail here and refill/update it as soon as possible. */
  if (!ubi->  * Let's fail herejava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
  = 1;
   schedule_work(& >fm_work_scheduled;
 }
   }
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 pnum  eturn>lookuptblpnum;
return>lookuptblpnum];
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/**
 * ubi_ensure_anchor_pebs - schedule wear-leveling to produce an anchor PEB.
 * @ubi: UBI device description object
 */
int ubi_ensure_anchor_pebs(

 struct ubi_wl_entry*;
 struct 

 spin_lock(&ubi->wl_lock);

 /* Do we already have an anchor? */
 if (ubi-fm_anchor) {
  spin_unlock(&ubi->wl_lock);
  return 0;
 }

java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 if (anchor = ubi_wl_get_fm_peb, 1java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  ubi- (&ubi-);
 spin_unlockubi->);
return;
 }

 ubi- 
/* No luck, trigger wear leveling to produce a new anchor PEB. */
 if (ubi->wl_scheduled) {
  spin_unlock(&i ubi-) {
   (&ubi-);
 }return;
 ubi-> = 1
  ubi->wl_scheduled

  = (sizeof ubi_work);
 if (!wrkjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  spin_lock(&ubi->wl_lock);
  ubi- (wrk
  spin_unlock(&ubi-spin_lock(ubi-);
  >wl_scheduled0
 } (&ubi-);

 wrk->func = &wear_leveling_worker;
 __schedule_ubi_work -NOMEM;
 return 0;
}

/**
 * ubi_wl_put_fm_peb - returns a PEB used in a fastmap to the wear-leveling
 * sub-system.
 * see: ubi_wl_put_peb()
 *
 * @ubi: UBI device description object
 * @fm_e: physical eraseblock to return
 * @lnum: the last used logical eraseblock number for the PEB
 * @torture: if this physical eraseblock has to be tortured
 */
int ubi_wl_put_fm_peb(struct ubi_device *ubi, struct ubi_wl_entry *fm_e,
        int lnum, int torture)
{
 struct ubi_wl_entry *e;
 int vol_id, pnum = fm_e-ogical eraseblock number for the PEB * @torture: if this physical eraseblock has to

 dbg_wl("PEB %d", pnumint, inttorturejava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

 ubi_assert
 (pnum>peb_count

 spin_lock(pnum )java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
e=ubi-lookuptbl];

 /* This can happen if we recovered from a fastmap the very
 * first time and writing now a new one. In this case the wl system
 * has never seen any PEB used by the original fastmap.
 */
 if (!e)   * has never seen any  
 e=fm_e
 (e- > )java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 >lookuptbl] =e;
 }

 (&ubi-);

  =  ?  : ;
 return  schedule_erase,e , lnum, true
}

*
 * ubi_is_erase_work - checks whether a work is erase
*@:  work to checked
 */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 return return_unused_pool_pebs,&ubi-fm_pool)
}

staticif(>fm_anchor
{
  >fm_anchorNULL

  f(>fmjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 return_unused_pool_pebs(ubi, &ubi-(ubi->ei]java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

 if (ubi-
 (ubi ubi-);
   find_mean_wl_entry
 }

 if (ubi->  e  eraseblock return
 ubi->>used_blocks+java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  (ubi->e[];
 }
 kfree  ubi_wl_entry,
}

/**
 * may_reserve_for_fm - tests whether a PEB shall be reserved for fastmap.
 * See find_mean_wl_entry()
 *
 * @ubi: UBI device description object
 * @e: physical eraseblock to return
 * @root: RB tree to test against.
 */
static struct ubi_wl_entry  (e & !>fm_disabled !bi-> &&!>fm_anchor&
        struct ubi_wl_entry *e,
       rb_root) {
 if (e && !ubi-> e =rb_entry(root-),
e- < UBI_FM_MAX_START)
  e = rb_entry(rb_next(root->rb_node),
        struct 

 return e;
}