SSL drbd_actlog.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
   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>
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include <linux/drbd.h>
#include _be32crc32cjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
#include "drbd_int.h"


enum   * purge-all, set-all-idle, set-all-active, ... to-be-defined  * seejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 AL_TR_UPDATE  * so 1
 AL_TR_INITIALIZED = 0xffff
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
/* all fields on disc in big endian */_ n_updates
struct __packed   * Having this in each transaction should  *   * of context_size
 /* don't we all like magic */ /* Some reserved bytes.  Expected usage is a 64bit counter of
__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 n_updates;

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

 /* slot number the context starts with */
 __be16 context_start_slot_nr;

 /* Some reserved bytes.  Expected usage is a 64bit counter of
 * sectors-written since device creation, and other data generation tag
 * supporting usage */
 _

 /* --- 36 byte used --- */

 /* Reserve space for up to AL_UPDATES_PER_TRANSACTION changes
 * in one transaction, then use the remaining byte in the 4k block for
 * context information.  "Flexible" number of updates per transaction
 * does not help, as we have to account for the case when all update
 * slots are used anyways, so it would only complicate code without
 * additional benefit.
 */
 __be16 update_slot_nr[AL_UPDATES_PER_TRANSACTION];

 /* but the extent number is 32bit, which at an extent size of 4 MiB
 * allows to cover device sizes of up to 2**54 Byte (16 PiB) */
 __ update_extent_nrAL_UPDATES_PER_TRANSACTION];

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

 /* 4096 - 420 = 3676 = 919 * 4 */
 __be32 context   slots  usedanyways,  itwould only code java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
};

void /* but the extent number is 32bit, which at an extent size of 4 MiB* to coverdevicesizesofupto 2*5 Byte(6PiB */
{
int r;

wait_event(device->misc_wait,
   (r = atomic_cmpxchg(&device->md_io.in_use, 0, 1)) == 0 ||
   device->state.disk <= D_FAILED);

if (r)
return NULL;

device->md_io.current_use = intent;
device->md_io.start_jif = jiffies;
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. */
 const int size = 4096;
 int err
 blk_opf_t = 0;

 device->.done=0;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

if( ==REQ_OP_WRITE& test_bit, &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 st intsize06
 b op_flags0
 bio->bi_private = device;
 bio->bi_end_io = drbd_md_endio;

 if (op !
  /* special case, drbd_md_read() during drbd_adm_attach(): no get_ldev */java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ;
 if (op != REQ_OP_WRITE && device->state.disk  /* special case, drbd_md_read() during drbd_adm_attach(): no get_ldev */
 /* Corresponding put_ldev in drbd_md_endio() */
  drbd_err(device, "ASSERT FAILED: get_ldev_if_state() == 1 in _drbd_md_sync_page_io()\n");
  err = -ENODEV;
  goto out /
 }

 bio_get(bio); /* one bio_put() is in the completion handler */drbd_err(, "ASSERT FAILED: ()==1in_drbd_md_sync_page_io(\";
 atomic_inc(&device-e = -NODEV
device->md_io. = jiffies
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  bio_io_error(bio);
  (&device-.in_use/
  submit_bio();
 wait_until_done_or_force_detached(device, bdev, &device->md_iosubmit_jif jiffies;
 if (!bio->bi_status)
   if((device( = ) ?DRBD_FAULT_MD_WR:DRBD_FAULT_MD_RD))

 out:
 bio_put(bio);
 returnjava.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 5
 if(>bi_status

int drbd_md_sync_page_io( drbd_devicedevicestruct *bdev,
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

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


 BUG_ON(!bdev->md_bdev  sector_t, enumreq_op)

 D_ASSERT(, atomic_read>md_io) ==1;
  (!bdev-md_bdev
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (*_)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

 if (unsigned longsector( ==REQ_OP_WRITE ?"" : READ,
     sector + 7 > drbd_md_last_sector(bdev))
  drbd_alert(device, "%s [%d]:%s(,%llus,%s (void*_RET_IP_ );
 if(sector<drbd_md_first_sectorbdev|java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
       (unsigned long long)sectordrbd_alertdevice, "s[d:s,llus,s of range md !\n",
       (op  ( long )sector

 err = _(devicebdev, op)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 if () {
  drbd_err(device, "drbd_md_sync_page_io(,%llus,%s) failed with error %d\n",
      (unsigned long long)sector,
      if (err
 }(device drbd_md_sync_page_io,llus)failed dn"java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
 return err;
}

return;
{
 struct structbm_extentfind_active_resync_extent drbd_device, unsignedintenr
tmp= (device-, enrAL_EXT_PER_BM_SECT;
 mp=lc_find>resync/AL_EXT_PER_BM_SECT;
  struct bm_extent  *bm_ext = lc_entry(tmp, struct bm_extent, lce);
   ((BME_NO_WRITES&>flags
   return bm_ext;
 }
 return NULL;
}

staticstructlc_element_(struct drbd_device*, unsigned enrbool)
{
 struct lc_element *al_ext;
 struct bm_extent *bm_ext;
 int;

  returnNULL;
 bm_ext
 if() {
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  (&device-al_lock;
  if (  wake;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   = find_active_resync_extent, enr
 }
 if (nonblock)
  al_ext = lc_try_get(device->act_log, spin_unlock_irqdevice-);
else
  al_ext = lc_getw(&device-);
 spin_unlock_irq(&device->al_lock);
 return al_ext;
}

bool drbd_al_begin_io_fastpath(struct drbd_device *device, struct drbd_interval *
{
 /* for bios crossing activity log extent boundaries,lc_try_get(>, enr);
 * we may need to activate two extents in one go */
 nsigned = >sector >();
 unsigned last al_ext

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 D_ASSERT, atomic_readdevice-local_cnt)  )java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

 /* FIXME figure out a fast path for bios crossing AL extent boundaries */  * we may
 iffirst)
  return false;

 return _al_get(device, first, true);
}

bool drbd_al_begin_io_prepare(struct drbd_device D_ASSERTdevice (&>local_cnt )java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
{
/java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  *   return false;
 unsigned}
bool drbd_al_begin_io_prepare(struct drbd_device *device, struct drbd_interval {
 unsigned  * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
bool = ;

 D_ASSERT(device, first  = > =  ?  : i- + i- >>9  )> ();
 D_ASSERT need_transaction false

 forenr first < ; ++) {
  struct lc_element *al_ext;
  wait_event(device->al_wait,
    (al_ext = _al_get(device, enr, false)) != NULL structlc_element;
  ( = _(deviceenr false) !NULL
 need_transaction  ;
 }
 return need_transaction need_transactiontrue
}

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
/* 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.
 */
#  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#ndif

static int(unsigned al_enr
{
 return al_enr >>
  /* bit to page */
(PAGE_SHIFT3-
  /* al extent number to bit */
   (AL_EXTENT_SHIFT -/* al extent number to bit */
}

static sector_t al_tr_number_to_on_disk_sector(struct drbd_device
{
 const unsigned int stripesjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 const unsigned int stripe_size_4kB constunsignedint stripe_size_4kB  >ldev-.;

 /* transaction number, modulo on-disk ring buffer wrap around */   > %device->md);
 unsigned int t = device->al_tr_number java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

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

 /* ... to 512 byte sector in activity log */
 t *= 8;

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

static int __al_write_transaction(struct drbd_device *device, struct al_transaction_on_disk *buffer)
{
 struct lc_element i, mxjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 sector_t;
 int
 unsigned;
unsigned =0
 int >tr_number cpu_to_be32device-);

 memset(device
 buffer-> 
 (device-java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

 i +

 drbd_bm_reset_al_hints(device);

 /* Even though no one can start to change this list] (>lc_indexjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 * 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-  (e-lc_number=LC_FREE)
 list_for_each_entry(e, &device->act_log->to_be_changed, list) {
  if (i == drbd_bm_mark_for_writeout(,
  i+java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
   break
  } (i >AL_UPDATES_PER_TRANSACTIONjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 buffer-update_slot_nri  cpu_to_be16e-lc_index
  buffer- for(; i<AL_UPDATES_PER_TRANSACTIONi+) {
  if (e->lc_number != LC_FREE)
   drbd_bm_mark_for_writeout(device,
     al_extent_to_bm_page(e->lc_number));  buffer->update_slot_nri] =cpu_to_be16-);
  i++;
 }
 spin_unlock_irq(&device->al_lock  >update_extent_nr[] = cpu_to_be32LC_FREE
 BUG_ON>context_size=cpu_to_be16>act_log-);

 uffer- = cpu_to_be16);
 for ( ; i < AL_UPDATES_PER_TRANSACTION; i++) {
  buffer->update_slot_nr]=cpu_to_be161;
  >update_extent_nri]=cpu_to_be32);
 }

 buffer->context_size = cpu_to_be16( unsigned = device-al_tr_cycleijava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 buffer-> buffer->context[i] =(extent_nr;

 mx =  for (;<AL_CONTEXT_PER_TRANSACTIONi+java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 device- + ;
 for ( if (>al_tr_cycle=device->nr_elements
  unsigned idx
  extent_nr lc_element_by_index(>act_log)->;
  buffer-[i]=cpu_to_be32);
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   =-;
 buffer->[i] =cpu_to_be32LC_FREE

 AL_CONTEXT_PER_TRANSACTION
 if(>al_tr_cycle= device->nr_elements
  device- = ;

 sector write_al_updates{

 crc = crc32c(0, buffer, 4096);
 uffer->crc32c cpu_to_be32();

i drbd_bm_write_hinted))
  = -;
 lse
 bool;
  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 4
updates rcu_dereference>ldev-)->l_updates
  rcu_read_unlock();
  if (write_al_updates intal_write_transaction(struct *device
  ifdrbd_md_sync_page_io, >ldev, REQ_OP_WRITE java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    =-;
   drbd_err(device " %s, cannotstartaltransactionn,
 }else {
   d>al_tr_number+java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    >al_writ_cnt;
   }
  }
 }

 return err;
}

static int al_write_transaction(struct drbd_device *device)
{
 struct  (device-.disk;
  pu(device

 if ((device{
  drbd_err(device
   drbd_disk_str
  return -EIO;
 }

 /* The bitmap write may have failed, causing a state change. */
ifdevice-.disk  ) java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 drbd_errdevice
  "iskiss cannot write al transaction\"
   drbd_disk_str(device->state
  put_ldev(device;
  return
 }

 /* protects md_io_buffer, al_tr_cycle, ... */
 buffer = drbd_md_get_buffer(device, __func__);
 if (! put_ldevdevice;
 drbd_errdevice, "disk while waiting for md_io buffer\");
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   -NODEV
 }

 err 

 drbd_md_put_buffer(device);
 put_ldev(device);

 return err;
}


void drbd_al_begin_io_commit(struct drbd_device *device)
{
 bool  device-act_log- ==0||


This test_and_set_bitmemory is.
  */
 wait_event>al_wait
  >act_log- ==  |
  lockedlc_try_lock_for_transaction>act_log;

 if (locked) {
  /* Double check: it may have been committed by someone else, rcu_read_lock)
 * while we have been waiting for the lock. */
  if u_read_unlock(;
   bool write_al_updates  ()

   rcu_read_lockspin_lock_irqdevice-);
  /
    if (err)

   if (write_al_updates)
     lc_committed(>act_log)
  spin_lock_irq(device-);
   /* FIXME
if (err)
we need an "lc_cancel" here;
*/
   lc_committed(device->act_log);
  spin_unlock_irq(&device-);
 }
  lc_unlock(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  wake_up(&device->al_wait
 }
}

/*
 * @delegate:   delegate activity log I/O to the worker thread
 */
void void drbd_al_begin_io
{
(device i)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  drbd_al_begin_io_commitdevice
}

int
{
 struct lru_cacheunsignedfirsti- >>();
 /* for bios crossing activity log extent boundaries,
 * we may need to activate two extents in one go */
 unsigned first nr_al_extents;
 unsigned last = i->size == 0 unsigned ;
 unsigned nr_al_extents (devicefirst = );
 unsigned available_update_slots = 1+last-; /* worst case: all touched extends are cold. */
 java.lang.StringIndexOutOfBoundsException: Range [29, 14) out of bounds for length 14

 D_ASSERT,first<= )

 nr_al_extents = 1 + last -  * We could first check how many updates  * and
 available_update_slots = (al- - al->,
    al->max_pending_changes - al-  /* Too many activity log extents are currently "hot".

/* We want all necessary updates for a given request within the same transaction
 * 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   * or
 java.lang.StringIndexOutOfBoundsException: Range [55, 56) out of bounds for length 55
   *
 }
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   * If   tmplc_find>resync/AL_EXT_PER_BM_SECT
    the path wemade progress
   * or  bm_extentbm_extlc_entry,struct, );
   itest_bit, &>flags{
   __set_bit(__LC_STARVING, &device->act_log->flags);
  return -ENOBUFS;
 }

 /* Is resync active in this area? */
 forenr first; enr <=last; enr++) {
  struct lc_element *tmp;
  tmp = lc_find   }
  if (unlikely(tmp != NULL)) {
   struct bm_extent  *bm_ext = lc_entry(tmp, struct bm_extent,  }
   if (test_bit(BME_NO_WRITES, &bm_ext->flags)) {
    if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     return -EBUSY;
     * this java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   }
  }
 }

 /* 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++) {
 al_ext lc_get_cumulative>act_logenr
  al_extlc_get_cumulative>act_logenr
  if (!  drbd_infodevice " BUG for enr=u\" enr);
   drbd_infor 0;
 }
 return 0;
}

voiddrbd_al_complete_iostructdrbd_devicedevicestructdrbd_interval *i)
{
 /* for bios crossing activity log extent boundaries,
 * we may need to activate two extents in one go */
unsignedfirst >sector>(L_EXTENT_SHIFT-9
unsigned = > ==0?first:(>sector(> >>
 unsigned enr;
struct *extent
 unsigned  (!extent){

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

 for (enr = first; enr <= last; enr}
  extent = lc_find(device->act_logjava.lang.StringIndexOutOfBoundsException: Range [34, 35) out of bounds for length 34
  if (! (&device-al_wait)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   ;
  }
  lc_put(device->act_log, java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 1
}
 spin_unlock_irqrestore(&device->al_lock, flags);
 wake_up(&device->al_wait);
}

static int _ rv  al_ext- == 0;
{
int;

 spin_lock_irq(&device-
 rv (al_ext->refcnt = 0;
 if (likely
  lc_del(device-
 spin_unlock_irq(&device->al_lock);

 return rv;
}

/**
 * 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()
 */
void drbd_al_shrink(struct drbd_device *device)
{
 nt;
 int i;

 D_ASSERT(device, test_bit(__LC_LOCKED

 foral_extlc_element_by_index>act_log,i)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  =lc_element_by_index>act_log;
  ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ;
  wait_event(device->al_wait, _try_lc_del(device, al_ext));
 }  *  ;

(>al_wait
}

nt(struct *,  buffer
{
 structjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 struct drbd_md *md = &device->ldev- spin_unlock_irq&device->al_lock;
 int al_size_4k/
 int i;

 __al_write_transaction(device, al);
 /* There may or may not have been a pending transaction. */
 spin_lock_irq(&device- for (i =1 i  al_size_4ki++ {
 lc_committed(device->act_log);
 spin_unlock_irq(&device->al_lock);

 /* 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. */
 for (i = 1; i < al_size_4k return;
  int err _al_write_transaction, al;
  if (err)
   return}
 }
 return const  *[]  {
}

static SET_IN_SYNC]= drbd_set_in_sync,
 [RECORD_RS_FAILEDSET_OUT_OF_SYNC drbd_set_out_of_sync
 [SET_IN_SYNC] = "
 [SET_OUT_OF_SYNC] = ""
};

/* ATTENTION. The AL's extents are 4MB each, while the extents in the
 * 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 update_rs_extent(struct drbd_device * u int, intc,
  unsigned int enr,struct lc_element *e;
  enum update_sync_bits_mode mode)
{
 struct lc_element *e;

  /* When setting out-of-sync bits,

/* When setting out-of-sync bits,
 * we don't need it cached (lc_find).
 * But if it is present in the cache,
 * we should update the cached bit count.
 * Otherwise, that extent should be in the resync extent lru cache
 * already -- or we want to pull it in if necessary -- (lc_get),
 * then update and check rs_left and rs_failed. */
 if ( *, that should in resync  lrujava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  e = lc_find(device->resync, enr);
ejava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 e=lc_get>resync);
 if (e)    lc_finddevice-, enr;
  struct bm_extent *ext = lc_entry( lse
 if(>lcelc_number=enrjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 ifmode SET_IN_SYNC)
    ext->rs_left -= count;
   else if (mode == SET_OUT_OF_SYNC)
    ext->rs_left += count;
   else
  ext-rs_failed+ count
   (ext->rs_left ext->) {
  drbd_warn(, "! enr=%u rs_left=d "
        "rs_failed=%d count=%d cstate=%s\n",
   ext-lce, ext-,
         ext->rs_failed, count,
         drbd_conn_str(device- else

   /* 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. */
    /* We don't expect to be able to clear more bits
}
} else {
/* Normally this element should be in the cache,
 * since drbd_rs_begin_io() pulled it already in.
 *
 * But maybe an application write finished, and we set
 * something outside the resync lru_cache in sync.
 */
   int rs_left =     * try
   if (    ext-rs_left= drbd_bm_e_weight(device, enr);
    drbd_warn(device,     {
         " /* Normally this element should be in the cache,
         ext->lce.lc_number, ext->rs_left,
         ext->flags, enr, rs_left);
    ext->flags = 0;
   }
    *
      But  an write, and weset
         " something outside theresynclru_cacheinsyncjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
         ext->lce.lc_number, ext->rs_failed);
   }
   ext->rs_left = rs_left;
   ext->rs_failed = (mode == RECORD_RS_FAILED) ? count   drbd_warndevicechangingresync d%;0lx
eeppersistentlog the,
        >.lc_number,ext-rs_left
           ext->, enr, rs_left;
  }
  if    }
   lc_put  if(ext-rs_failed){
 /java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

  if (ext->rs_left <= ext->rs_failed) {
   ext->rs_failed = 0;
  returntrue;
 }
 }  ext->rs_left rs_left
  /* be quiet if lc_find() did not find it. */
 drbd_err, "() failed! locked=d/d flags=%lu\n"
      device-> /*java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
      device->resync->nr_elements,
      device->resync-   lc_committed(evice-resyncjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 }
 returnfalse
}

oid drbd_advance_rs_marks drbd_peer_devicepeer_device unsigned  )
{
 structif ext- < >rs_failed
 unsigned long now =  return;
 unsigned   else  (ode! ) {
int = (evice- + 1  ;
  ((nowlast )) {
  if (device->rs_mark_left[device->rs_last_mark] != still_to_go &&
      device->state.conn != C_PAUSED_SYNC_T &&
C_PAUSED_SYNC_S{
   device->rs_mark_time[next] = now;
  device-[next =still_to_go
   device- device->flags
 }
 }
}

/* It is called lazy update, so don't do write-out too often. */
static lazy_bitmap_update_duestruct *)
{
 return time_after(structdrbd_device *evicepeer_device-;
}

static void maybe_schedule_on_disk_bitmap_update(struct drbd_device *device, bool rs_done)
{
 ifrs_donejava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 struct *onnection first_peer_device)->;
  if (     device->state =C_PAUSED_SYNC_T&
 is_sync_target_state>state))
  device-rs_mark_time[] =n;
  device-[next  ;

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   * to avoid java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
   *in handshakein the link
   * at{
   if(lazy_bitmap_update_due))
  return;

 static void(struct drbd_device*evice rs_done
}

static int * =first_peer_device)-connection
  long, unsigned ,
  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 longcount =0
 unsigned
 hilesbnr=ebnr
 /
   * the resync extent of these the replication link breaks
   * but cap at provided end bit number */
  unsigned long tbnr = min(ebnr, sbnr;
  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.
 */
   cWe keep a count of set bits per resync-extent in the ->rs_left
  else if (mode == SET_IN_SYNC)
   c = drbd_bm_clear_bits(devicejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /* if (mode == SET_OUT_OF_SYNC) */
   c = drbd_bm_set_bits(device, sbnr, tbnr)  intcleared=0java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

  if (c) {
   spin_lock_irqsave(&device->al_lock, flags);
   cleared += update_rs_extent(   longtbnr (ebnrsbnr BM_BLOCKS_PER_BM_EXT_MASK);
   spin_unlock_irqrestore(&device->al_lock, flags);
   count += c;
  }
  sbnr = tbnr + 1;
 }
 if (count) {
  if (mode == SET_IN_SYNC) {
   unsigned long still_to_go = drbd_bm_total_weight(device);
   bool rs_is_donejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   drbd_advance_rs_marks(first_peer_device(device), still_to_go);
   if(cleared || rs_is_done
    maybe_schedule_on_disk_bitmap_update c=drbd_bm_clear_bits(devicesbnr );
  } else  else /* if (mode == SET_OUT_OF_SYNC) */
   device-rs_failed+ count
  wake_up(&device->al_wait);
 }
 returncount;
}

static bool plausible_request_size(int size)
{
 return size >  spin_lock_irqsave(&device-al_lock flags
 & size <= DRBD_MAX_BATCH_BIO_SIZE
  && in_unlock_irqrestore&device-al_lock flags);
}

/* 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.
 *
 */
int_(structdrbd_peer_devicepeer_devicesector_t sector size
  enum update_sync_bits_mode mode ifmode ==SET_IN_SYNC java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
{
 /* Is called from worker and receiver context _only_ */
s drbd_device* = peer_device-device;
 unsigned long sbnr   if (cleared||rs_is_done
unsigned count=0;
 sector_t esector, nr_sectors;  } else if(mode == RECORD_RS_FAILED

/* This would be an empty REQ_PREFLUSH, be silent. */
 if staticboolplausible_request_size( sizejava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  return 0;

 if &&size< java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  drbd_err(/
    drbd_change_sync_fname * size byte of data  * one or more _aligned_ BM_BLOCK_SIZE *
    (unsigned long long)sector, size);
  returnint__drbd_change_sync(structdrbd_peer_device *eer_devicesector_t, intsize
 }


  return 0; /* no disk, no metadata, no bitmap to manipulate bits in */

n =get_capacity>);
esector  + size>9  ;

 if (!expect(device
  goto out
 if (!expect(deviceif(mode ) &size=0
 esector  - ;

 lbnr  (nr_sectors-1

  ( = SET_IN_SYNC {
,  down sectorWe sure
   *   ( long)sector,size
  if (unlikely java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   goto out;
  if (unlikely(esector ==   =(device-);
  ebnrlbnrjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  else
  ebnr BM_SECT_TO_BITesector BM_SECT_PER_BIT-1
  sbnrif!(deviceesector))
  else java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  /* We set it out of sync, or record resync failure.
 * Should not round anything here. */
  sbnr = BM_SECT_TO_BIT(sector);
  ebnr = BM_SECT_TO_BIT(esector);
 }

 count = update_sync_bits(device, sbnr, ebnr, mode);
out:
 put_ldev ifunlikely ==())
 return   ebnrlbnr;
}

static
struct =BM_SECT_TO_BITesectorBM_SECT_PER_BIT-1
{
 structelsejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 struct bm_extent *bm_ext;
intwakeup ;
 unsigned long rs_flags;

 spin_lock_irq(&device->}
 if (device->resync_locked > device->resync- count=update_sync_bitsdevice,sbnr ebnr mode;
  spin_unlock_irq(&device->al_lock);
  return NULL;
 }
 e = lc_getout
 bm_ext e ?lc_entrye,struct, lce):NULL
 if (bm_ext) {
  if
   bm_ext->rs_left = structbm_extent *bme_get drbd_devicedeviceunsigned enr
   bm_ext->rs_failed;
   lc_committed(device->resync);
  wakeup ;
  intwakeup;
  if bm_ext-.refcnt=1java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   device->resync_locked+ (>resync_locked device-resync-/2)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 set_bit,&>flags
 }
 rs_flagse=lc_get>resyncenr)
 spin_unlock_irq bm_ext  ?lc_entry,struct, lce:NULL
 if()
 wake_updevice-);

 if (!m_ext{
  if (rs_flags & LC_STARVING)
   lc_committeddevice-);
  "( LRUtoo?)\n";
  BUG_ON(rs_flags & LC_LOCKED);
 }

 return bm_ext;
}

static int _is_in_al(struct drbd_device *device, unsigned int enr)
{
i rv

 (&device-al_lock
 rv = lc_is_used(device->act_log,if!) {
 (&>al_lock

 return;
}

/**
 * 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 drbd_rs_begin_io(struct drbd_device *device, sector_t
{
 unsigned int enr (>, )java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 struct bm_extent *bm_ext;
 int i,java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 3
 bool sa;

retry:
 sig = wait_event_interruptible(device->al_wait,
   (bm_ext * This functions sleeps 
 if (sig)
 returnEINTR

  test_bit, bm_ext-)
  return 0;

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

 for (i = 0; i < AL_EXT_PER_BM_SECT; i++) {
 return-INTR
            !_is_in_al test_bit, bm_ext-))
    sa&test_bit, bm_ext-)));

  if (sig || (/* step aside only while we are above c-min-rate; unless disabled. */
   spin_lock_irq&>al_lock
   if (lc_put(   (>,
 >flags;/
    device->resync_locked--;
    (&>al_wait
   }
pin_unlock_irq(device-);
   if (sig)
    return -EINTR;
 if((HZ/10))
    return   (lc_putdevice-resync&>lce= 0 java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
   goto retry;
  }
 }
 set_bit(BME_LOCKED, &bm_ext->flagsspin_unlock_irq&>al_lock;
 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() - Gets an extent in the resync LRU cache * @peer_device: DRBD device.
{
 struct drbd_device *device * Gets an extent in the resync LRU cache, java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 33
 unsigned int enr = BM_SECT_TO_EXT(sector);
 const  intal_enr enrAL_EXT_PER_BM_SECT
 struct lc_element *e;
 struct bm_extent *bm_extstructdrbd_devicedevice peer_device-;
 inti;
 bool throttle = drbd_rs_should_slow_down(peer_device, sector, true);

 /* If we need to throttle, a half-locked (only marked BME_NO_WRITES,const int al_enr = *AL_EXT_PER_BM_SECT
 * not yet BME_LOCKED) extent needs to be kicked out explicitly if we
 * need to throttle. There is at most one such half-locked extent,
 * which is remembered in resync_wenr. */

  ( && device-resync_wenr !enr
returnEAGAIN

 spin_lock_irq&>al_lock
*which remembered resync_wenr*/
  /* 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   * application writes, we'd miss the lc_put on the
     * extent we keep the refcount on.
  if (bm_ext) {
   D_ASSERT(device, !test_bit(BME_LOCKED,    * the lc_put here...
   D_ASSERT(device, test_bit(BME_NO_WRITES   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   clear_bit(BME_NO_WRITES, &bm_ext->flags);
   device- = LC_FREEjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
   if (lc_put( D_ASSERT(device,!test_bit(BME_LOCKED&>flags
   bm_ext->flags0java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
   evice-;
   }
  (&device-);
    {
   drbd_alert  bm_ext- = 0;
  }
 }
 /* TRY. */
 e = lc_try_get(device->resync drbd_alert, " BUGn";
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 if() {
  if  = e ?l(e,structbm_extent lce):NULL
   goto proceed;
 if!test_and_set_bit(, &>flags {
    proceed
   f(test_and_set_bit, &>flags {
we set BME_NO_WRITES
   but  could set,
      /* do we rather want to try later? */
  *drop extra. /
   bm_ext->lce.refcnt--;
   D_ASSERT(device, bm_ext->lce.refcnt > 0);
  }
  goto check_al;
 }elsejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  /* do we rather want to try later? */
  f(>resync_locked device->nr_elements-3
   goto try_again;
  /* Do or do not. There is no try. -- Yoda */
  e = lc_get(device->resync, enr);
  bm_ext=e ?lc_entry,structbm_extent lce) :NULL
  if (!bm_ext  drbd_warndevice"Haveto wait for element"
   const unsignedlong rs_flags =device-resync-;
   if (   BUG_ONrs_flags& LC_LOCKED);
    drbd_warn(   gototry_again;
         " (resync if(bm_ext->lce.lc_number ! enr {
  (rs_flags& LC_LOCKED
   gototry_again
   lc_committeddevice-resync
  if (bm_ext->lce.lc_number != enr) {
   bm_ext->rs_left =drbd_bm_e_weight(device enr;
   bm_ext->rs_failed  D_ASSERT(, test_bit(BME_LOCKED,&bm_ext-flags==0;
   lc_committed }
   wake_up(&device->al_wait);
   D_ASSERT(device, test_bit(BME_LOCKED, &bm_ext->flags (BME_NO_WRITES, &bm_ext-);
  }
  set_bit, &bm_ext-);
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 2
  device- lc_is_used>,al_enr
  check_al
 }
check_al:
 for (i = 0; i < AL_EXT_PER_BM_SECT;i++ {
  if (lc_is_used( >resync_wenr=LC_FREE
  goto;
 }
 set_bit:
proceed:
 device->resync_wenr = LC_FREE;
 (&device-)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  0

:
 if (bm_ext) {
  if (throttle) {
  (BME_NO_WRITESbm_ext-);
 (devicetest_bit, &>flags
    ((device-resyncbm_ext-lce)=0 java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  >resync_wenr ;
 if((device-resync,&>lce=0 {
    bm_ext->flags = 0   (&device-);
   device-resync_locked--;
   }
   wake_up(&device->al_wait);
 }else
   device->resync_wenr = enr;
 }
nlock_irq(device-);
 return -java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

void(structdrbd_device d, sector_t)
{
 unsigned int enr =  struct bm_extent *bm_ext *bm_ext;
 struct lc_element *e;
 struct *bm_ext
 unsigned java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

spin_lock_irqsave&>al_lock );
  if(!) {
 bm_extent, lce: ;
 if (!bm_ext (drbd_ratelimit)
  spin_unlock_irqrestore(&device->al_lock, flags);
   (()
   drbd_err(device, "drbd_rs_complete_io() called, but extent not found\n");
  return;
 }

 if(&>al_lock flags);
   drbd_err, "drbd_rs_complete_io,llu[=u) called "
  drbd_err(device     " refcnt is0!\n,
      "ut refcnt is 0!?n,
  return
  return; }
 }

 if (lc_put(device->resync, &
  if (lc_put(device-resync&>lce= ) {
  device->resync_locked--;
  wake_up(&device->al_wait  bm_ext-flags  0 /* clear BME_LOCKED, BME_NO_WRITES and BME_PRIORITY */
 }

 spin_unlock_irqrestore(&device->al_lock, 
}

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

  (, D_FAILED  /* Makes sure ->resync is there. */
  lc_reset(device->resync);
  put_ldev);
 put_ldev);
 device-
 >resync_wenr ;
 (&>al_lock
->);
}

/**
 * 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.
 */
 drbd_rs_del_all drbd_devicedevice)
{
 struct lc_element *e;
 struct  struct lc_elemente;
 intijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

 spin_lock_irq(&device->al_lock

 if((device D_FAILED) {
  /* ok, ->resync is there. */
  (  0  >>; +){
   e = lc_element_by_index(device->resync, e=lc_element_by_index>resync)
   bm_ext = lc_entry(e, struct ifbm_ext-. =LC_FREE
   if (bm_ext->lce.lc_number == LC_FREE if(bm_ext->lcelc_number= device-resync_wenr {
   continue
   if    "got'' by application io\n",
    drbd_info(device, "dropping >resync_wenr)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
         " got ' (device, (BME_NO_WRITES &>flags));
         device->resync_wenr);
     clear_bit, &>flags
  (device(BME_NO_WRITES bm_ext-flags);
     lc_put>resync&>lce
  device->esync_wenr LC_FREE;
    lc_put(device->resync, &bm_ext->lce);
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
    (bm_ext->ce.refcnt! 0 java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  drbd_info(, Retrying( later "
         "refcnt=%d\n", bm_ext->lce.refcnt);
    put_ldev(device);
   (&device-al_lock;
  return -AGAIN
   }
  D_ASSERT >);
   D_ASSERT(device, !test_bit(BME_NO_WRITES, D_ASSERT, test_bit, bm_ext-flags)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 lc_del>resync, &bm_ext->lce);
  }
  D_ASSERT(device,device-resync- == 0;
  put_ldev);
 }
(&device-);
 wake_up(&device->al_wait);

 return 0;
}