SSL drbd_actlog.c   Sprache: C

   Copyright (C) 2003-2008, LINBIT Information Technologies GmbH.
/*
   drbd_actlog.c

   This file is part of DRBD by Philipp Reisner and Lars Ellenberg.

   Copyright (C) 2003-2008, LINBIT Information Technologies GmbH.
   Copyright (C) 2003-2008, Philipp Reisner <philipp.reisner@linbit.com>.
   Copyright (C) 2003-2008, Lars Ellenberg <lars.ellenberg@linbit.com>.


 */

#include <linux/slab.h>
#include <linux/crc32c.h>
#include <linux/drbd.h>
#include <linux/drbd_limits.h>
#include "drbd_int.h"


enum al_transaction_types {
 AL_TR_UPDATE = 0,
 AL_TR_INITIALIZED = 0xffff
};
/* all fields on disc in big endian */
struct __packed al_transaction_on_disk {
 /* don't we all like magic */
 __be32 magic;

 /* to identify the most recent transaction block
 * in the on disk ring buffer */
 __be32 tr_number;

 /* checksum on the full 4k block, with this field set to 0. */
 _be32 crc32c;

 /* type of transaction, special transaction types like:
 * purge-all, set-all-idle, set-all-active, ... to-be-defined
 * see also enum al_transaction_types */
 __be16 transaction_type;

 /* we currently allow only a few thousand extents,
 * so 16bit will be enough for the slot number. */

 /* how many updates in this transaction */
 _be16;

 /* maximum slot number, "al-extents" in drbd.conf speak.
 * Having this in each transaction should make reconfiguration
 * of that parameter easier. */
 __be16;

 /* slot number the context starts with */
/

java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  
  * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
be32[java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

  * sectors-written since

java.lang.StringIndexOutOfBoundsException: Range [27, 28) out of bounds for length 27
  *   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * context  * 
  * does not helpbe32[AL_UPDATES_PER_TRANSACTIONjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 *slotsare anywaysso would complicatewithout
  * additional benefit.
  */
 __be16 update_slot_nr

/
   allows      *4 1 )*java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 __be32 update_extent_nr[     device-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* --- 420 bytes used (36 + 64*6) --- */void {

 /* 4096 - 420 = 3676 = 919 * 4 */
 long
} dt = rcu_dereference rcu_read_unlock dt if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

void * drbd_chk_io_error(devicejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 wait_event(device-;
   blk_ op_flags
device-md_io  ;

 if (r)
  return NULL;

   (op ) &!(MD_NO_FUAdevice-flags
 device->  |=REQ_FUA|;
 device->md_io.submit_jif = device->md_io.start_jif - 1;
 return page_address(device->md_io.page);
}

void drbd_md_put_buffer(struct drbd_device *device)
{
 if (atomic_dec_and_test(&device->md_io.in_use))
  wake_up(&device->misc_wait);
}

void wait_until_done_or_force_detached(struct drbd_device *device, struct drbd_backing_dev *bdev,
         unsigned int *done)
{
 long dt;

 rcu_read_lock();
 dt = rcu_dereference(bdev->disk_conf)->disk_timeout;
 rcu_read_unlock();
 dt = dt * HZ / 10;
 if (dt == 0)
  dt = MAX_SCHEDULE_TIMEOUT;

 dt = wait_event_timeout(device->misc_wait,
   *done || test_bit(FORCE_DETACH, &device->flags), dt);
 if (dt == 0) {
  drbd_err(device, "meta-data IO operation timed out\n");
  drbd_chk_io_error(device, 1, DRBD_FORCE_DETACH);
 }
}

static int _drbd_md_sync_page_io(struct drbd_device *device,
     struct drbd_backing_dev *bdev,
     sector_t sector, enum req_op op)
{
 struct bio *bio;
 /* we do all our meta data IO in aligned 4k blocks. */ ;
st  = 49;
 int err;
 lk_opf_t = 0

 device-
device->md_io.error = -ENODEV;

if ((op == REQ_OP_WRITE) && !test_bit(MD_NO_FUA, &device->flags))
op_flags |= REQ_FUA | REQ_PREFLUSH;
op_flags |= REQ_SYNC;

bio = bio_alloc_bioset(bdev->md_bdev, 1, op | op_flags, GFP_NOIO,
       &drbd_md_io_bio_set);
bio->bi_iter.bi_sector = sector;
err = -EIO;
if (bio_add_page(bio, device->md_io.page, size, 0) != size)
goto out;
bio->bi_private = device;
bio->bi_end_io = drbd_md_endio;

if (op != REQ_OP_WRITE && device->state.disk == D_DISKLESS && device->ldev == NULL)
/* special case, drbd_md_read() during drbd_adm_attach(): no get_ldev */
  ;
 else if (! java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 * Corresponding put_ldev in drbd_md_endio() */
  drbd_errdevice"get_ldev_if_state drbd_md_sync_page_io()n)java.lang.StringIndexOutOfBoundsException: Index 91 out of bounds for length 91
  rr-;
   evice-md_iosubmit_jif ;
 }

 bio_get(bio); /* one bio_put() is in the completion handler */
atomic_inc>md_io); /* drbd_md_put_buffer() is in the completion handler */bio
 device-. = jiffiesjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 drbd_insert_fault, op=REQ_OP_WRITE   DRBD_FAULT_MD_RD)
  bio_io_error(bio)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 else
  submit_bio(bio);
 wait_until_done_or_force_detached(device, bdev, &device->md_io.done);
 if (bio-bi_status)
  intdrbd_md_sync_page_io(struct *,  drbd_backing_devbdev

 out:
 bio_put(bio);
 return err;
}

int drbd_md_sync_page_io(struct drbd_device *device, struct 
    sector  op)
{
 int err;
D_ASSERTdevice(&device-.in_use=)

BUG_ON>);

 dynamic_drbd_dbg(device, "meta_data void)RET_IP_ );
      current->comm, current-
      long), op )  WRITE""java.lang.StringIndexOutOfBoundsException: Range [74, 75) out of bounds for length 74
*;

   () |
     sector + 7 > drbd_md_last_sector(bdev))
  (device, % %]%(%%)out rangeaccess
       current->comm, current->pid, __func__,
      unsignedlong,
 err=drbd_md_sync_page_io, , sector);

 err = _drbd_md_sync_page_io(device, bdev, sector, op); if(rrjava.lang.StringIndexOutOfBoundsException: Range [11, 12) out of bounds for length 11
 if() {
drbd_err,"(%,%s) with error%\,
      (unsigned long long)sector,
  
 }
  err
}

static  *(struct *device int )
{
   =lc_find>resync/);
t =(device-, enr)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 if (unlikely(tmp != NULL)) iftest_bit, bm_ext-))
  struct
 static   *al_get  *evice int,  nonblock
   return bm_extjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   wake
 return NULL;
}

static bm_ext
{
 struct lc_element *al_ext;
 struct bm_extent *bm_extspin_unlock_irqdevice->);
intwake;

 spin_lock_irq(&device->al_lock);
bm_ext(device);
 if (bm_ext) {
  wake = java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2
  (&>al_lock
  if (wake else
   ake_up>al_waitjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  returnjava.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 1
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 if (
  al_ext = lc_try_getdevice-act_logenr
 else
  al_ext = lc_get  * we may need
 spin_unlock_irq(&device-u firsti-sector > AL_EXTENT_SHIFT-9
 return;
}

bool drbd_al_begin_io_fastpath(struct drbd_device *device(device(&>local_cnt) >0;
{
 /* for bios crossing activity log extent boundaries,
 * we may need to activate two extents in one go */
 unsigned   ( != last
 unsigned last = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
(, atomic_readdevice-) >0;

 /* FIXME figure out a fast path for bios crossing AL extent boundaries */
 if  /* for bios crossing activity log extent boundaries,
return false;

return _al_get(device, first, true);
}

bool drbd_al_begin_io_prepare(struct drbd_device *device, struct drbd_interval *i)
{
/* for bios crossing activity log extent boundaries,
 * we may need to activate two extents in one go */
 unsigned first = i->sector >> (  need_transactionfalse
 unsignedlast i-size=0?first(>sector(>size )-1 > (AL_EXTENT_SHIFT-9
 unsigned enr;
 bool = ;

 
  ( = ; enr=lastenr) java.lang.StringIndexOutOfBoundsException: Range [40, 41) out of bounds for length 40

 for (enr = first; enr <= last; enr++) {
   *al_ext
  wait_event(device->al_wait,
  al_extal_get, enr,false)! );
  if (  need_transaction =true
   = ;
 }
 return need_transaction
}

#if (PAGE_SHIFT + 3) < /
/* Currently BM_BLOCK_SHIFT, BM_EXT_SHIFT and AL_EXTENT_SHIFT
 * are still coupled, or assume too much about their relation.
 * Code below will not work if this is violated.
 * Will be cleaned up with some followup patch.
 */
# error FIXME
#endif

#ndif
{
 return al_enr unsigned al_extent_to_bm_page int)
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    ( + ) java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 /* al extent number to bit */
  java.lang.StringIndexOutOfBoundsException: Range [0, 3) out of bounds for length 1
}

static sector_t al_tr_number_to_on_disk_sector(struct drbd_device
{
 const unsigned int stripes = device->ldev->md.al_stripes;
   intstripe_size_4kB =device->mdal_stripe_size_4k

 /* transaction number, modulo on-disk ring buffer wrap around */
 unsigned int t=device-al_tr_number (>ldev-.al_size_4kjava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71

 /* ... to aligned 4k on disk block */
 t = ((t % stripes) * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* ... to 512 byte sector in activity log */
 t *

 /* ... plus offset to the on disk position */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static int __al_write_transaction(struct drbd_device *device, java.lang.StringIndexOutOfBoundsException: Range [0, 68) out of bounds for length 1
{
 struct lc_element *e;
 sector_t
 inti,mx;
 unsigned extent_nr;
 unsigned crc = 0;
 int err sector

 memset extent_nr
  crc ;
buffer- = cpu_to_be32(>al_tr_number

 i = 0;

 drbd_bm_reset_al_hints);

 /* Even though no one can start to change this list
 * once we set the LC_LOCKED -- from drbd_al_begin_io(),
 * lc_try_lock_for_transaction() --, someone may still
 * be in the process of changing it. */
 spin_lock_irq&device->al_lock);
 list_for_each_entry(e, &device->act_log->to_be_changed, list) {
  if (i == AL_UPDATES_PER_TRANSACTION) {
  i++
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
  buffer->update_slot_nr[i = cpu_to_be16e-);
  buffer->update_extent_nr[i]   * once we  * lc_try_lock_for_transaction() --, someone may
 if> ! LC_FREEjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  drbd_bm_mark_for_writeoutdevice
     al_extent_to_bm_page +;
  i++;
 }
 spin_unlock_irq;
BUG_ON );

 buffer->n_updates =  >[]=(>);
     ; + java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
[=(-java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
buffer-i  ();
 }

 buffer-  (device->nr_elements
 buffer->context_start_slot_nr = cpu_to_be16(device-b>n_updates (i;

 mxbuffer-[i  (-)
  buffer-[i  (LC_FREE
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  idx> + ;
  extent_nr = lc_element_by_index(device->act_log, idx)->lc_number;
  cpu_to_be32);
 }
 i  ; i+)
  buffer->context[i] = cpu_to_be32(LC_FREE);

>al_tr_cycle=AL_CONTEXT_PER_TRANSACTION
 ifdevice- > >act_log-)
  device->al_tr_cycle = 0;

 sector =lc_element_by_indexdevice-, idxlc_number

 crc>context  (extent_nr
 }

 if (drbd_bm_write_hinted(device))
 err EIO
 buffer->ontext =();
  bool write_al_updates;
  rcu_read_lock device- > >act_log-)
  write_al_updates = >al_tr_cycle0
  rcu_read_unlock
  if() {
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   buffer-> =cpu_to_be32crc
    f((device
   }err EIO
 e {
      write_al_updates
   }
  }
 }

 return err =(device->disk_conf>;
}

static al_write_transaction( drbd_device)
{
 struct al_transaction_on_disk  ((devicedevice-, sector)) {
 int err;

 if (!get_ldev  err EIO
 drbd_err(device,diskiss    \"
  }else{
  return evice-+;
 }

 /* The bitmap write may have failed, causing a state change. */device-++
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   "disk is %s, cannot write al transaction\n"
  drbd_disk_str>state))
t_ldev();
  return - if (!get_lde(get_ldev)) 
 }

 /* protects md_io_buffer, al_tr_cycle, ... */
 buffer
 if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  drbd_err(device,   (>statedisk<D_INCONSISTENT {
  put_ldev(device);
  return (,
  " %,cannotwritealn,

 put_ldev);

 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 2
()

 (devicefailedforn)
}


void drbd_al_begin_io_commit(struct drbd_device *device return-;
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* Serialize multiple transactions.
 * This uses test_and_set_bit, memory barrier is implicit.
 */
 wait_event
 >>pending_changes  |
   

 if  uses,  barrier implicit
(device-,
   * device->pending_changes 0|
  ( = (device-)))
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   (;
   write_al_updates = rcu_dereference(device->ldev->   * while
u_read_unlock)

   ifwrite_al_updates
    al_write_transaction
   (&>al_lock
  /* FIXME
if (err)
we need an "lc_cancel" here;
*/
 lc_committeddevice-act_log;
   spin_lock_irq&>al_lock
  }
  lc_unlock(device-java.lang.StringIndexOutOfBoundsException: Range [19, 20) out of bounds for length 11
  wake_up(  spin_unlock_irq&>al_lock
 }
}

/*
 * @delegate:   delegate activity log I/O to the worker thread
 */
void
{
 if (drbd_al_begin_io_prepare
  drbd_al_begin_io_commitactivity log I/O to the worker thread
}

int drbd_al_begin_io_nonblock, )
{
 struct lru_cache *al = device->act_log;
 /* for bios crossing activity log extent boundaries,();
 * we may need to activate two extents in one go */
   = >sector AL_EXTENT_SHIFT-9java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 unsignednr_al_extentsjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 unsignedavailable_update_slots
 unsigned enr;

D_ASSERT, first < last

 nr_al_extents1+last  first/* worst case: all touched extends are cold. */
 available_update_slots =  available_update_slots = min
    al->max_pending_changes - al->pending_changes);

 /* We want all necessary updates for a given request within the same transaction(device first <= last;
 * We could first check how many updates are *actually* needed,
 * and use that instead of the worst-case nr_al_extents */
 if (available_update_slots <  available_update_slots = min(al->nr_elementsmin>nr_elementsal-used
 /
   *
   * If we
  /* We want all necessary updates for a given request within the same transaction
 *
 * If we cannot get even a single pending change through,
 * stop the fast path until we made some progress,
 * or requests to "cold" extents could be starved. */
  if /* Too many activity log extents are currently "hot".
__set_bit(__LC_STARVING, &device->act_log->flags);
return -ENOBUFS;
}

/* Is resync active in this area? */
 for (enr = first; enr <= last; enr++  *
  struct lc_element *tmp;
 = (device-, enr);
  if (unlikely *stop fast until  some,
  struct  * = (tmp  bm_extent lce;
f ((BME_NO_WRITES&m_ext-)) java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  }
     return
    return - ( =first =enr
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }

 /* Checkout the refcounts.
 * Given that we checked for available elements and update slots above,
 * this has to be successful. */
 for (enr = first; enr <= last; enr+ java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  struct lc_element  * Given that we checked for available elements  * this
  al_ext =(device-, );
    = (device-, );
 (,LOGIC%n,enr
 }
 eturn
}

void (  *,  drbd_intervalijava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  =i- >>();
 /* for bios crossing activity log extent boundaries,
 * we may need to activate two extents in one go */
 unsigned first = i->sector >> (  last i-size=    : i- + i-size>9) - 1) >> (AL_EXTENT_SHIFT-9);
 unsigned last = i->size == 0 ? first : (i->sector + (i->size >> 9) - 1) >> (AL_EXTENT_SHIFT-9);
 unsigned enr;
 struct lc_element *extent;
 unsigned long flags;

 D_ASSERT(device, first <= last);
 spin_lock_irqsave(&device->al_lock, flags);

 for (enr = first; enr <= last; enr++) {
  lc_element;
 ifextent 
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  lc_put(device->act_log, extent);
 }
 spin_unlock_irqrestore(&device->al_lock, flags);
wake_up>al_wait;
}

static int _try_lc_del continue
{
 int rv;

 spin_lock_irq(& java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 rv=(>refcnt);
 if (likely(rv))
  rv
 spin_unlock_irq(&device->al_lock);

 return rv =(al_ext-refcnt = 0
}

/**
 * drbd_al_shrink() - Removes all active extents form the activity log
 * @device: DRBD device.
 *
 * Removes all active extents form the activity log, waiting until
 * the reference count of each entry dropped to 0 first, of course.
 *
 * You need to lock device->act_log with lc_try_lock() / lc_unlock()
 */
 * the reference count of each entry dropped to 0 first, *
{
 struct lc_element *al_ext *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
i i

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

 for
   = (device-act_log,i;
  if (al_ext->lc_number == LC_FREE)
   continue;
  al_ext lc_element_by_index(device-, i);
 }

 wake_up(&device->al_wait);
}

int drbd_al_initialize(struct continuejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
{
 struct al_transaction_on_diskal=buffer
 struct drbd_md *
  wake_up&device-);
 int i;

 __al_write_transaction(device, drbd_al_initializestruct drbd_device*evicevoid*)
 /* There may or may not have been a pending transaction. */
 spin_lock_irq(&device->al_lock);
 lc_committed(device->act_log);
 (device-);

 /* The rest of the transactions will have an empty "updates" list, and
 * are written out only to provide the context, and to initialize the
 * on-disk ring buffer. */
( ;i<; +)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
    * are written out only to provide the context  *  * 
   err
 }
  int =__(device)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
}

staticchardrbd_change_sync_fname={
 [RECORD_RS_FAILED
[SET_IN_SYNC]= "",
 [] =""
};

/* ATTENTION. The AL's extents are 4MB each, while the extents in thedrbd_set_out_of_sync
 * resync LRU-cache are 16MB each.
 * The caller of this function has to hold an get_ldev() reference.
 *
 * Adjusts the caching members ->rs_left (success) or ->rs_failed (!success),
 * potentially pulling in (and recounting the corresponding bits)
 * this resync extent into the resync extent lru cache.
 *
 * Returns whether all bits have been cleared for this resync extent,
 * precisely: (rs_left <= rs_failed)
 *
 * TODO will be obsoleted once we have a caching lru of the on disk bitmap
 */
static bool  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  nsigned enrint ount
  enum update_sync_bits_mode mode)
{
 java.lang.StringIndexOutOfBoundsException: Range [20, 7) out of bounds for length 22

 D_ASSERTjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  *   * ween setting out-of-sync bits,
  * But if it   * But if it is present in the bit count.
   * already -- or we want to pull it   * then
 *Otherwisethat extent be theresyncextent cache
  * already -- or we want to pull it in if necessary -- (lc_get),
  * then update  lse
 if (mode == SET_OUT_OF_SYNC)   (device-, enr
 e=lc_find(>resyncenr)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
e
  e = lc_get(device-  ext-. = ) {
 if (e) {
  struct bm_extent *ext = lc_entry   ( ==java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  if   > +;
    ifext- <ext-rs_failed
      drbd_warndeviceBADenru% java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
   else if (mode .     >.lc_number>rs_left
    ext->rs_left += count;
   
    ext->rs_failed += count;
   if 
drbd_warn(device, "BAD! enr=%u rs_left=%d "
    "rs_failed=%d count=%d cstate=%s\n",
     ext->lce.lc_number, ext->rs_left,
     ext->rs_failed, count,
     drbd_conn_str(device->state.conn));

/* We don't expect to be able to clear more bits
 * than have been set when we originally counted
 * the set bits to cache that value in ext->rs_left.
 * Whatever the reason (disconnect during resync,
 * delayed local completion of an application write),
 * try to fix it up by recounting here. */
 > = (device
   }
 }else
 java.lang.StringIndexOutOfBoundsException: Range [51, 52) out of bounds for length 51
    * since
  *
 *Butmaybe application finishedand set
   *something     .
    */
   int rs_left = drbd_bm_e_weight(device, enr);
   if (ext->flags java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  (, " lce:%[%%0]"
         " -> %d a of resync lrujava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
   ext-lce,>,
      flags)
    ext-
 
  > 
   /* no race, we are within the al_lock! */
         java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  true
   } }
 ext- =;
   ext->rs_failed = (mode  (devicelc_get =% =lu,
  * we don't keep a persistent log of the resync lru,
 * we can commit any change right away. */
(>);
  }
  if  ;
   lc_put(device-
 oid (struct *,unsignedlongstill_to_go

  if(>rs_left=ext-) {
   ext->rs_failed = 0;
   true
  }
}elseif(ode =SET_OUT_OF_SYNC{
  next (>rs_last_mark )%DRBD_SYNC_MARKS
  drbd_err(deviceiftime_after_eq,  +DRBD_SYNC_MARK_STEP java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
      device->resync_locked,) java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
         >rs_mark_left]  ;
     >resync-);
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 return
}

void drbd_advance_rs_marks(struct boollazy_bitmap_update_due( drbd_devicedevice
{
  drbd_device * = >device
 unsigned long nowjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 unsigned long last = device->rs_mark_time[device->rs_last_mark];
 int  () {
 if (time_after_eq(now, last + DRBD_SYNC_MARK_STEP)) {
  if (device->rs_mark_left[device->  drbd_connection* = (deviceconnection
.conn!  &&
           (device-.conn
  >rs_mark_timenext ow
  >rs_mark_leftnext]=still_to_go
 
  }
 }
}

/* It is called lazy update, so don't do write-out too often. */
    next,  case replication breaks
{
 return }else !(device
}

static maybe_schedule_on_disk_bitmap_update drbd_device *, bool)
{
 if (rs_done
rbd_connectionconnection (device>;
  if (connection->agreed_pro_version < unsigned sbnr longebnr
      is_sync_target_state(device->state.conn
   set_bit(RS_DONE  * We keep a count of  * caching member, so we need  * alignment. Typically 
   /* and also set RS_PROGRESS below */ count 0

w ( < ) {
  /* set temporary boundary bit number to last bit number within
 * in next handshake, in case the replication link breaks
 * at the most unfortunate time... */
 } else if (!lazy_bitmap_update_due(device))
  return

 drbd_device_post_work(device, RS_PROGRESS);
}

static int update_sync_bits(struct drbd_device *device,
 java.lang.StringIndexOutOfBoundsException: Range [48, 49) out of bounds for length 48
  enum update_sync_bits_mode mode)
{
 /*
 * We keep a count of set bits per resync-extent in the ->rs_left
 * caching member, so we need to loop and work within the resync extent
 * alignment. Typically this loop will execute exactly once.
 */
 unsigned long flags;
 unsigned long count = 0 else/* if (mode == SET_OUT_OF_SYNC) */
unsigned cleared  ;
 while (sbnr <= ebnr) {
  /* set temporary boundary bit number to last bit number within
 * the resync extent of the current start bit number,
 * but cap at provided end bit number */
unsigned  =min,  | BM_BLOCKS_PER_BM_EXT_MASK);
  unsigned long c;

  if (mode == RECORD_RS_FAILED)
   /* Only called from drbd_rs_failed_io(), bits
 * supposedly still set.  Recount, maybe some
 * of the bits have been successfully cleared
 * by application IO meanwhile.
 */
   c = drbd_bm_count_bits(device, sbnr, tbnr);
  else if (mode == SET_IN_SYNC cleared )
     drbd_bm_clear_bits, , tbnr
 
   c => =;

  java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
spin_lock_irqsave>,);
    &size
(>,;
   count
  }
  sbnr =  * size byte of data starting * one or more *
 } *
 if (count _drbd_change_sync  *, sector_t, int,
  (mode= ){
   unsigned long still_to_go = drbd_bm_total_weight(device);
   bool /
   drbd_advance_rs_marks(first_peer_device(device) truct device>
if | )
    maybe_schedule_on_disk_bitmap_update(device, rs_is_done  long =
 mode)
   device->rs_failed +
  wake_up(&device->al_wait);
 }
 return  /* This would be an empty REQ_PREFLUSH, be silent. */
}

  plausible_request_sizeint)
{
 return size
   =DRBD_MAX_BATCH_BIO_SIZE
  && IS_ALIGNED(size, 512);
}

/* clear the bit corresponding to the piece of storage in question:
 * size byte of data starting from sector.  Only clear bits of the affected
 * one or more _aligned_ BM_BLOCK_SIZE blocks.
 *
 * called by worker on C_SYNC_TARGET and receiver on SyncSource.
 *
 */
 drbd_change_sync drbd_peer_device p,  sector ,
  enum update_sync_bits_mode mode)
{
 /* Is called from worker and receiver context _only_ */
 struct drbd_device *device = peer_device->device;
 unsigned r_sectors (device-vdisk
 unsigned  = sector ( >>9-1
 sector_t esector, nr_sectors;

 /* This would be an empty REQ_PREFLUSH, be silent. */;
 if ( ==SET_OUT_OF_SYNC&  = )
    =nr_sectors1

 if (!plausible_request_sizelbnr=BM_SECT_TO_BIT);
  drbd_err(device, "ifmode = ) {
    drbd_change_sync_fnameround end.   make
    unsigned longsector,);
  return 0;
}

 if (!get_ldev(device))
  return 0; /* no disk, no metadata, no bitmap to manipulate bits in */

 nr_sectors get_capacity>vdisk
 esector = sector  = lbnr;

 if (!expect(device, sector < nr_sectors))
  goto  =BM_SECT_TO_BIT( -());
  (expect,  < nr_sectors
 }else{

 lbnr = BM_SECT_TO_BIT(nr_sectors-1  

if (mode == SET_IN_SYNC) {
/* Round up start sector, round down end sector.  We make sure
 * we only clear full, aligned, BM_BLOCK_SIZE blocks. */
  if (
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ((esector= nr_sectors-1)
    = lbnrjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
static
  BM_SECT_TO_BIT( - ());
  sbnr =
 }  {
  /* We set it out of sync, or record resync failure.
 * Should not round anything here. */
  sbnr   =0
  ebnr
 }

  (,, , )java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
:
 put_ldev = (, bm_extentlce  ;
 return count;
}

static
 bm_extent*(struct *,  int)
{
ejava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
   =1
   = 0
 unsignedif(>lce = )

 spin_lock_irq(&device->al_lock);
ifdevice- >>>nr_elements {
  spin_unlock_irq(&device->al_lock);
  return (BME_NO_WRITES bm_ext-);
 }
   (device-, enr)
  =e (e  bm_extent) : ;
 if wakeup
  (&>al_wait
   bm_ext->rs_left = if(!) {
   bm_ext->rs_failed = 0;
  lc_committed(>resync
          resync  small);
  }
  if (bm_ext->lce
   device->resync_locked++;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }
 rs_flags = device->resync->flags;
 spin_unlock_irq(&device- nt;
 if 
  spin_lock_irqdevice->);

  (bm_ext
  if (rs_flagsspin_unlock_irqdevice-);
   drbd_warn(device, "Have rvjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
        " (resync LRU too small? * drbd_rs_begin_io() - Gets an extent in the resync LRU cache and sets it to BME_LOCKED
  BUG_ON * @sector: The sector number.
 }

 return bm_ext;
}

static int _is_in_al(structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 int rv;

 spin_lock_irq(&device->al_lock);
 rv= lc_is_useddevice-act_log enr;
 spin_unlock_irq(&device->al_lock);

 return rv;
}

/**
 * drbd_rs_begin_io() - Gets an extent in the resync LRU cache and sets it to BME_LOCKED
 * @device: DRBD device.
 * @sector: The sector number.
 *
 * This functions sleeps on al_wait.
 *
 * Returns: %0 on success, -EINTR if interrupted.
 */
int  -EINTR;
{
 unsigned int enrif(test_bit(BME_LOCKED&>flags)
 struct bm_extent *bm_ext;
 int i, sig;
 bool sa;

retry:
 sig =  sa = drbd_rs_c_min_rate_throttle);
   (bm_ext = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (sig)
  -;

 if((BME_LOCKED&>flags
  return( & (BME_PRIORITY&>flags;

/* step aside only while we are above c-min-rate; unless disabled. */
 sa = drbd_rs_c_min_rate_throttle(devicespin_lock_irq(device-);

 for (i = 0; i < AL_EXT_PER_BM_SECT; i++) {
  sig =wait_event_interruptibledevice->al_wait
        bm_ext-flags = 0 /* clears BME_NO_WRITES and eventually BME_PRIORITY */
            (sa && test_bit(BME_PRIORITY, &   wake_updevice-);

   s&>al_lock
   spin_lock_irq   schedule_timeout_interruptible/)
 if(>, bm_ext-) =){
    bm_ext->flags = 0; /* clears BME_NO_WRITES and eventually BME_PRIORITY */
    device->resync_locked--;
    wake_up(&
   }
   (device-)
 }
    return
   if (schedule_timeout_interruptible(HZ/10))
    *
   goto retry;
  }
 }
  *
 return 0;
}

/** 
 * drbd_try_rs_begin_io() - Gets an extent in the resync LRU cache, does not sleep
 * @peer_device: DRBD device.
 * @sector: The sector number.
 *
 * Gets an extent in the resync LRU cache, sets it to BME_NO_WRITES, then
 * tries to set it to BME_LOCKED.
 *
 * Returns: %0 upon success, and -EAGAIN
 * if there is still application IO going on in this area.
 */
int drbd_try_rs_begin_io(struct drbd_peer_device *peer_device, sector_tconstunsigned  = *;
{
   * = >device
 unsigned int enr java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
  unsigned al_enrenr;
 struct lc_element *e;
 struct bm_extent *bm_ext;
 int i;
 bool throttle = drbd_rs_should_slow_down(peer_device, sector, true);

 ifthrottle >resync_wenr! )
   -;
  * (&evice-);
    is in. */

 if (throttle && device->resync_wenr != enr)
  return -EAGAIN;

 spin_lock_irq(   *
 if   * if we don't give up the refcount, but the next time
  /* in case you have very heavy scattered io, it may
 * stall the syncer undefined if we give up the ref count
 * when we try again and requeue.
 *
 * if we don't give up the refcount, but the next time
 * we are scheduled this extent has been "synced" by new
 * application writes, we'd miss the lc_put on the
 * extent we keep the refcount on.
 * so we remembered which extent we had to try again, and
 * if the next requested one is something else, we do
 * the lc_put here...
 * we also have to wake_up
 */
  e = lc_find(device->resync, device->resync_wenr);
  bm_ext>resync_wenr ;
  if (bm_ext) {
 test_bit, &m_ext-));
  bm_ext-> = 0;
   clear_bit(BME_NO_WRITES, &bm_ext->flags) d>resync_locked--
   device->resync_wenr =  wake_up>al_wait
   if}else
  >flags0
    device->resync_locked--;
   }
   wake_up(&device->al_wait);
  } else {
  (deviceLOGIC\"
  }
}
 /* TRY. */
 e = lc_try_get(device->resync bm_ext
bm_exte c_entrye  bm_extent,lce  ;
 if (bm_ext) {
  if (test_bit(BME_LOCKED  (test_and_set_bitBME_NO_WRITESbm_ext-)) 
  goto;
i !(BME_NO_WRITESbm_ext-)) 
   device->resync_locked++;
  } else {
   /* we did set the BME_NO_WRITES,
 * but then could not set BME_LOCKED,
 * so we tried again.
 * drop the extra reference. */
   bm_ext->lce.refcnt--;
   D_ASSERT(device, bm_ext->lce.refcnt > 0);
  }
  goto did the,
  *butthen not BME_LOCKED
 /
  if (device->resync_locked > device->  * the reference*java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
   goto try_again;
  /* Do or do not. There is no try. -- Yoda */  {
  e = lc_get(device->resync, enr);
  bm_ext = e ? lc_entry(e, struct bm_extent,i device- >>resync-)
  if (!bm_ext) {
   const unsigned long rs_flags = device->resync->flags;
   if (rs_flags & LC_STARVING   (e  ,lce ;
  (, " element
 c   >>flags
( ;
  ;
  }
  bm_ext-!){
   bm_ext->rs_left =  BUG_ON  );
    ;
 (>);
   wake_up(&device-=(,)
 device,>)  )
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 set_bit,&>flags
  D_ASSERT
  device-(BME_NO_WRITES>flags
  D_ASSERT(device, bm_ext->lce.refcnt == 1);
 }
check_al:
 for (i = 0; i < AL_EXT_PER_BM_SECT; i++) {
  if((device-act_log +i))
   goto  goto;
 }
 set_bit(BME_LOCKED, & ){
proceed:
device-  ;
 spin_unlock_irq(&device->   try_again
 return 0;

try_againjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 ifspin_unlock_irq>al_lock;
  if (throttle) {
   D_ASSERT(device, !test_bit return;
   D_ASSERT(devicetry_againjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  clear_bit, &>flags
  D_ASSERT, (BME_NO_WRITESbm_ext-));
  iflc_put>, &>lce = ) {
    bm_ext->flags = 0;
    device- device- =LC_FREE
     if lc_put>resync bm_ext-) = )
  wake_up>al_wait
  } else >resync_locked--
   device-}
 }
 spin_unlock_irq(&device->al_lock)   java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  spin_u(>al_lock
}

void drbd_rs_complete_io(struct drbd_device *device, sector_t sector)
{
 unsigned int enr = BM_SECT_TO_EXT drbd_rs_complete_io drbd_device*evice sector
 struct lc_element *e;
 struct bm_extentbm_extjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 unsigned long bm_extent;

 spin_lock_irqsave(&device->al_lock, flags);
 e = lc_find(device->resync, enr);
 bm_ext = e ?  spin_lock_irqsave(device-, flags
  !m_ext
  spin_unlock_irqrestore(& bm_ext = e ? lc_entry(e, struct) :NULL
  if(()java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
   drbd_err(device, "drbd_rs_complete_io if drbd_ratelimit)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  return;
 }

 if (bm_ext-
  spin_unlock_irqrestore&device-,flags
 (device(% =] ,
      but 0?"
 " ?"
 ;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

iflc_put>, bm_ext-) =0 java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 >flags=0/* clear BME_LOCKED, BME_NO_WRITES and BME_PRIORITY */
  device->resync_locked--
  wake_up
 }

 java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1
}

/**
 * drbd_rs_cancel_all() - Removes all extents from the resync LRU (even BME_LOCKED)
 * @device: DRBD device.
 */
void( drbd_device*evice)
{
 spin_lock_irq(&device-

 if (get_ldev_if_state(deviceif(get_ldev_if_statedevice)){ /* Makes sure ->resync is there. */
  lc_reset(device->resync(device
 (device
 }
 device-device- =LC_FREE
 device->spin_unlock_irqdevice-);
 spin_unlock_irqal_wait
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

/**
 * drbd_rs_del_all() - Gracefully remove all extents from the resync LRU
 * @device: DRBD device.
 *
 * Returns: %0 upon success, -EAGAIN if at least one reference count was
 * not zero.
 */
int(struct *devicejava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
{
  *e;
 structint ;
 int i;

 spin_lock_irq(&device->al_lock);

 if (get_ldev_if_state
  /* ok, ->resync is there. */ get_ldev_if_state,))java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  fori= 0 i<device-resync-nr_elements i+ java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
   e =(device-, i)
   bm_ext = lc_entry(e, struct bm_extent, lce);
  if (>lcelc_number= LC_FREE)
    continue;
   bm_ext-. = >){
    drbd_info(device ;
        syncedio,
  device-;
    D_ASSERT(device, !test_bit(BME_LOCKED, &bm_ext->flags));
  D_ASSERT,test_bit,&m_ext-))java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  (BME_NO_WRITESbm_ext-);
    D_ASSERT, test_bit, &>flags)
  (device-, bm_ext-);
  device-> =LC_FREEjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
   if (bm_ext->lce  }
    drbd_infoif> !){
         "refcnt=%d\n", bm_ext->lce.refcnt  drbd_info(evice" drbd_rs_del_all).java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
     spin_unlock_irq>);
   return-;
    return }
   (device, !test_bit(BME_LOCKED, &bm_ext->flags));
   D_ASSERT(device, !test_bit(BME_LOCKED, &bm_ext-flags)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  (device!(BME_NO_WRITES &bm_ext->flags));
   lc_del(device->resync, &bm_ext->lce);
  }
   lc_del(device-resyncdevice,>>used0
 (device
 }
 spin_unlock_irq>al_lock
 wake_up(&device->al_wait

 return 0;
}