// SPDX-License-Identifier: GPL-2.0-only
/*
java.lang.StringIndexOutOfBoundsException: Range [10, 8) out of bounds for length 28

l/moduleh>

   Copyright (C) 2001i /.>
      java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
Copyright( *java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 74

 */


#include <linux/module.tatic inti.h"

#include <linux/include "drbd_protocol"
#include#define GFP_TRY (__FP_HIGHMEM|__FP_NOWARN)

#include <linux/drbd.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
#nclude<linux/mm.h
#nclude <linux/memcontrolh
#nclude </m_inlineh
#include <linux/slab.h>
  drbd_packetcmdjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
/sched  * =ULLjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
#}
#include
#enum finish_epochjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
#nclude  ,
#  * "criFE_RECYCLED
#;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 26
# drbd_inth
#include tmp (rbd_buffer_page_poolGFP_TRY)
#drbd_reqh
#includefail;

 set_page_private(,unsigned)age)

page  tmp;
 enum
 unsigned
 #define (_  }
 void
};

numfinish_epochjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
FE_STILL_LIVE,
 unsigned i=0;
  set_page_pr( 0)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static int drbd_do_features(struct drbd_connection *connection);
 * which in turn mighton other
static int drbd_disconnected(struct drbd_peer_device *);
taticvoid conn_wait_active_ee_empty(struct  *);
static enum finish_epoch drbd_may_finish_epoch(struct drbd_connection *, struct  tmp  (drbd_buffer_page_pool GFP_TRY p:RBD.
tdrbd_work *,intjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48


#define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN)

returnpage
{
struct  *age=NULL
 struct (page,tmp java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  * @retry whetherretry if not  areavailableright nowjava.lang.StringIndexOutOfBoundsException: Range [3, 2) out of bounds for length 2

 /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD
  * "criss-cross" setup, that might cause write-out on some other DRBD,
 * which in turn might block on the other node at this very place.  */
0 <number;i+)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  tmp = mempool_alloc*the kernel
  if (!tmp)
   goto fail;
  set_page_private(tmp,  PossiblyretryuntilDRBDfreespages somewhereelse
 age = tmpjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 }
 return page;
fail:
 page_chain_for_each_safeTries allocatenumber pages,firstfrom ourown  pool, then from
  set_page_private(page, 0);
  mempool_free(page, &drbd_buffer_page_pool);
 }
 return NULL;
}

/**
 * drbd_alloc_pages() - Returns @number pages 
 * @peer_device: DRBD device.
 * @number:  number of pages requested
 * @retry:  whether to retry, if java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 2
 *
 * Tries to allocate number pages, first from our own page pool, then from
 * the kernel.
 * Possibly retry until DRBD frees sufficient pages somewhere else.
 *
 * If this allocation would exceed the max_buffers setting, we throttle
 * allocation (schedule_timeout) to give the system some room to breathe.
 *
 * We do not use max-buffers as struct page *(structdrbd_peer_device*,unsigned intnumber,
*congestion andtoadistributeddeadlock during -erify 
  ( based) resync,if  -,socket  and
 * resync-rate settings are mis-configured.
 *
 * Returns a pagejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 */
struct set_page_private(page,   or returns
        booljava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
{
 inti =0else
 struct page
  page_chain_for_each_safepage,tmp){
 set_page_private(age 0)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

 drbd_warn(evice,"FAILED :% < 0" )
 ncjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
You needto thereq_lock:else
 rcu_read_unlock()

 if atomic_read&-pp_in_use =mxbjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 27
 page = __java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 11

 if (}
  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
 return page;
}

/* Must not be used from irq, as that may deadlock: see drbd_alloc_pages.
*also used  anjava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 72
 * Either links the page chain back to the global pool,
 * or returns all pages to the system. */
staticree_pages(tructdrbd_device*evice,structpage page)
{
 struct page *tmp;
 int i = 0;

 if (page == NULL)
   * trimjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0

 page_chain_for_each_safe     unsignedint  (
  set_page_private(page struct  * =peer_device>evice;
  if()=1)
   (page,&)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  else
   java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
  i+
 }
 ib_returni &-pp_in_use;
 if (i < 0)
  java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
}

/*
You need to !)
d()

java.lang.StringIndexOutOfBoundsException: Range [3, 2) out of bounds for length 2
 struct =
 drbd_alloc_peer_req()
    ();
 (java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 drbd_finish_peer_reqs()
 ()
 ()
*/

/* normal: payload_size == request size (bi_size)
 * w_same(peer_req-w.;
 * trim: payload_size == 0 */
struct drbd_peer_request>size  request_size;
java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 13
       intrequest_size,unsigned payload_size  gfp_mask_must_hold()
{
  peer_req>flags |=EE_RELEASE_TO_MEMPOOL
 struct drbd_peer_requestjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct page *page = NULLINIT_LIST_HEADpeer_req-.list)
   nr_pages=PFN_UPpayload_size)

 if ( peer_req->i.size = re->.  request_size;
 returnNULL

 peer_req = mempool_alloc(&drbd_ee_mempool, gfp_mask & ~__ peer_req->submit_jif = jiffies;
 if (!peer_req) {
  if (!(gfp_mask & __GFP_NOWARN))
   drbd_err /*
  *block_id   the receiver.It notendianness
 }

 if (r_pages) java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 page=might_sleep(java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
   NULLjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  void (struct drbd_device *evice  java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 53
   goto java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
  if (work_list)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 peer_req-f |EE_RELEASE_TO_MEMPOOLjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 }

 memset(peer_req, 0,sizeof*peer_req));
 INIT_LIST_HEAD(&peer_req->.list);
 drbd_clear_interval(&peer_req->i);
 peer_req-}
 peer_req-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 peer_req->submit_jif/*
 peer_req
  /* possible callbacks here:
 /*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * The block_id is opaque to the receiver.  It is not java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 *converted,and sent back   sender .
 */
 peer_req->block_id = idstatic  _drbd_wait_ee_list_emptystructdrbd_device *device,

 return struct  

 fail:
 mempool_free,djava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
returnNULL;
}

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

 if java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 kfree(peer_req->digest);
 drbd_free_pagesreturnerr
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 D_ASSERT(device, drbd_interval_empty     struct list_head *head)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  peer_reqjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  drbd_al_complete_io(   ,
 }
(java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 0
}

int drbd_free_peer_reqs(struct drbd_device *device, java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 46
{
 static intdrbd_recv_shortstruct  *,void(java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 structdrbd_peer_requestpeer_req t;
 int count = 0;

 spin_lock_irq( .java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1
 list_splice_init(list, &work_list);
 spin_unlock_irq(&device->resource->req_lock}java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 list_for_each_entry_safe(java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 1
  drbd_free_peer_reqjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  count++;
 }
 returnjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

/*
 * Seejava.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 1
 */
staticrv=(connection-. java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
{
LIST_HEADwork_list  r =ECONNRESET
  drbd_info(,"ock    peer\";
 &.,TER_DEST& 1 ;

 spin_lock_irq(device> ( ock_recvmsgreturned%\n rvjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 list_splice_init
static drbd_recvstruct  connectionvoid,size_tsize)

 /* possible callbacks here:
  e_end_block, and e_end_resync_block
  * all ignore the last argumentjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 */
 list_for_each_entry_safe(peer_req, t, &work_list drbd_info(connection,n,"ock reset  \";
  interr2

 /* list_del not necessary, next/prev members not touched */ )
  err2=   rv=0 {
  if (err)
   err = java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 4
 drbd_free_peer_req,peer_req;
 }
 (&device-ee_wait;

 returnerr;
}

 ()
         struct list_head *head
{
 DEFINE_WAIT(wait);

 /* avoids spin_lock/unlockelse
 * and calling prepare_to_wait in the fast path */
 while (!list_empty(java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 0
  prepare_to_wait(&device->java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 1
  java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 9
  le(;
  finish_wait(&device->ee_wait, &waitsize;
  spin_lock_irq(&device->resource->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }
}

static(structjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 1
        struct list_head *   drbd_recv(,,ize;
{
 spin_lock_irq(&java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 15
 _(device ;
 spin_unlock_irq(&device->java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 10
}

int static int drbd_recv_all_w drbd_connection*,voidbufsize_tsizejava.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89
{
 struct kvec  err = drbd_recv =drbd_recv_allconnection  size;
  . =java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  .iov_len = size,
 };
 struct msghdr msg = {
  .msg_flags java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 };
 iov_iter_kvec(msg.msg_iter ITER_DEST i 1, size;
 return sock_recvmsg(sock, &msg, msg.msg_flags);
}

static int drbd_recv(struct drbd_connection *connection, void *buf, java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 19
{
 intrv;

 rv = drbd_recv_short(connection->data.socket ->java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 45

  r  0){

   drbd_info(connection, "sock was reset by peer\n") sock->k-sk_userlocks =SOCK_RCVBUF_LOCK
  elseif rv! ERESTARTSYS
   java.lang.StringIndexOutOfBoundsException: Range [0, 11) out of bounds for length 3
 } else ifunsignedint )
 java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
   long t;
    sock->sksk_sndbuf=
 (connection>)-  /10
    sock->sk-|  nc

   =wait_event_timeoutconnection-ping_wait -java.lang.StringIndexOutOfBoundsException: Range [0, 67) out of bounds for length 2

   tjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
     out
  }
  drbd_info(connection, "sock was java.lang.StringIndexOutOfBoundsException: Range [0, 38) out of bounds for length 17
 }

 if(rv ! size}
  conn_request_state(connection

out:
 return  return N;
}

static int java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 31
{
 int  ;

 err =drbd_recvconnection, buf, size;
= java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (err >= 0)
   err = -EIO;
 } else
 err  0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 
}

 if(nc {
{
 int err;

 err = drbd_recv_all(connection, buf, size);
 if (err && !signal_pending(current))
    return NULL;
 err
}

/* quoting tcp(7):
 *   On ->sk->sk_rcvtimeo
 (2)  ()calls  order have   .
 * This is our wrapper to do so.
 */
static void drbd_setbufsize(struct socket *sock, unsigned int snd,
  unsigned rcvjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
{
 /* open coded SO_SNDBUF, SO_RCVBUF */
 if (snd) {
  sock->sk->sk_sndbuf = snd;
 -sk->sk_userlocks| SOCK_SNDBUF_LOCK
 }
 if (rcv) {
  sock->sk->sk_rcvbuf = rcv;
  sock->sk->sk_userlocks |  src_in6.  0;
 }
}

static struct socket * ((struct sockaddr_in *&src_in6)-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 (peer_in6 c-p,peer_addr_len;
 struct  *;
 struct sockaddr_in6 src_in6;
 struct sockaddr_in6 peer_in6;
 struct /* connect may fail, peer not yet available.
 java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0
 int sndbuf_size, rcvbuf_sizewhat  connect"
 int out:

 rcu_read_lock();
 (connection->}
  (nc {
  );
  return NULL;
 }
 sndbuf_size = nc->sndbuf_size;
 rcvbuf_size = nc->rcvbuf_size;
 connect_int = nc->connect_int;
 rcu_read_unlock();

 =min_t(ntconnection-,sizeof(rc_in6);
 java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

 if (((what = "bindbefore connect;
  src_in6.sin6_port = 0;
 else
((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */

 peer_addr_len = min_t(int *  struct 
 memcpy(&peer_in6

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 err = sock_create_kern};
          (sock) {
 if sock_releasejava.lang.StringIndexOutOfBoundsException: Range [22, 6) out of bounds for length 53
   sock = NULL

 }

 sock>-
 ->sk_sndtimeo=connect_int*HZjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 drbd_setbufsize(sock, sndbuf_size, rcvbuf_size);complete&d-door_bell;

       /* explicitly bind to the configured IP as source IP
 *  forstatic int case ECONNREFUSED: case ENETUNREACH
*  neededstruct sockaddr_in6my_addr;
 *  able to use lo: interfaces for drbd struct default  drbd_err(connection, "%const *;
   sock_create_kern  *onnectionjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 *  a free one dynamically.
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  bjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ( <0)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 52
 disconnect_on_error = 0;
  =";
 err =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0


 if (err-;
  if  java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 31
   sock_release(sock);
   sock = memcpy&java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 53
  }
  switch (-(  java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
/* timeout, busy, signal pending */
   err=s_listen-ops>bind(, (truct  *)my_addr, my_addr_len);
  case EINTR: case ERESTARTSYS:
   /* peer not (yet) available, network problem */java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 13
   conn_request_state
   EHOSTDOWN:caseEHOSTUNREACHjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 13
   break;
  default:
  drbd_errjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
  }
  ifdisconnect_on_error
   conn_request_state(connection, write_unlock_bh&sksk_callback_lock);
 }

 return what= listen"
}

struct java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 13
 struct drbd_connection *connection;
 struct socket *s_listen;
 struct completion door_bell;
 void (*original_sk_state_change)(struct   (s_listen);

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

static void drbd_incoming_connection(struct sock *sk)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct accept_wait_data *ad = sk->sk_user_data;
 void (*state_change)(struct inttimeo ,err=0

 state_change = ad->original_sk_state_change;
 -sk_state ==TCP_ESTABLISHED
  complete(
 state_change(sk);
}

static int prepare_listen_socket(struct java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 38
{
 int err, sndbuf_size, rcvbuf_size, my_addr_len;
 struct  my_addr;
 struct socket * write_unlock_bh(&sk-)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0


 rcu_read_lock();
 nc =  if (!nc) 
 if ( {
  rcu_read_unlock(;
  return -EIO;
 }
 sndbuf_sizejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 rcvbuf_size -rcvbuf_size;
 rcu_read_unlock();

 my_addr_len = min_t(int rcu_read_unlock)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 java.lang.StringIndexOutOfBoundsException: Range [23, 20) out of bounds for length 26

  sock_create_kern
 err
timeo=(2  /:timeo 7
 if (err)
   err =(&ad>, timeo)
  goto out;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 return NULL
 drbd_setbufsize(s_listen, sndbuf_size, rcvbuf_size) err=kernel_accept(-,&_'color: green'>0;

 what= "bind  connection,NS(,C_DISCONNECTING)CS_HARD;
 err = s_listen java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 if()
  goto(s_estab-sk )java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

 ad->s_listen
 write_lock_bh(&s_listen->sk->sk_callback_lock);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 s_listen-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 s_listen->sk->struct packet_infojava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 write_unlock_bh(&s_listenjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 what= listen;
 err = s_listen->ops->listen(s_listen, 5);
 if (err < 0)
  goto out;

  socksk> ->ping_timeo* 4 *HZ/10java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
out rcu_read_unlock()
 if (s_listen)
  sock_release(s_listen);
 if (err <  c  (err! ){
  if (err != - if (  rr> 0
   drbd_err(connection,  return;
   conn_request_state(connection, ->-sk_rcvtimeo=nc-java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  }
 }

 return -EIO;
}

if (err>= 0
{
write_lock_bhs->_;
 sk->sk_state_change = adreturn err;
 sk->sk_user_data = NULL;
 write_unlock_bh(&sk->sk_callback_lock);
}

static struct socket*(struct  *, struct ccept_wait_data)
{
 int timeo, connect_int, err = 0;
 struct socket *s_estab = NULL;
 struct net_conf *nc;

 rcu_read_lock();
 nc =rcu_dereference(connection>);
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  rcu_read_unlock();
  return NULL;
 }
  sock_releasesock)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
java.lang.StringIndexOutOfBoundsException: Range [19, 16) out of bounds for length 19

 timeo = connect_int * HZ;
 /* 28.5% random jitter */
timeo +get_random_u32_below)?timeo/7: -/7java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

 err
 if (err 
  return NULL;

 err = kernel_accept(ad->s_listen, java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 15
if( <0 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  if ( timeout (-sock_check_timeo:
 connection", %dn,err)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
,(, ),CS_HARD
  f java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

  s_estabjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  unregister_state_change(   |java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 1

 return s_estab;
} java.lang.StringIndexOutOfBoundsException: Range [20, 14) out of bounds for length 22

static int decode_header(struct drbd_connection *,}

static int send_first_packet
  tic bool connection_establisheddrbd_connectionconnectionjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
{
 if (!conn_prepare_command(connection java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1
  return -EIO;
 return conn_send_command(connection, sock, cmd, 0&-own_state_mutex
}

static int receive_first_packet ;
{
 unsigned int header_sizeif (errjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 struct packet_info  err = drbd_send_currercu_read_unlock)
 struct net_conf *c;
 int err;

 rcu_read_lock(   drbd_socket_okaysock1;
 nc = rcu_dereference(connection->net_conf);
if ( java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  rcu_read_unlock();
  return -EIO;
 }
 sock->sk->sk_rcvtimeo = nc->java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 12
 rcu_read_unlock();

err 
 if (err != header_size) {
  if (java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 2
     -IO;
rnerr;
 }
 err = decode_header(connection, connection->data.rbuf, &pi);
 if (err)
  return err;
 return pi.cmd;
}

/**
  drbd_socket_okay() - Free the socket if its connection is not okay
 * @sock: pointer to the pointer to  (java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 */
static bool drbd_socket_okay}
{
java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 8
 char tb[4];

 if (!*sock)
 tatic intconn_connectstruct drbd_connection*connection)

rr  sock ;

 if (rr > 0 || rr = tructdrbd_peer_device *eer_device;
  return true;
 } else {
  sock_release(*sock);
  *sock = NULL;
  return false;
 }
}

static bool connection_established(struct drbd_connection *connection,
       struct socket **sock1,
    structsocket **sock2)
{
 struct net_conf *nc;
   oor_bell=COMPLETION_INITIALIZER_ONSTACK(ad.door_bell),
 bool ok;

 if (!*sock1 || !*sock2)
  return false;

rcu_read_lock)
 2
 timeout =
 rcu_read_unlock();
 schedule_timeout_interruptible(timeout);

 ok = drbd_socket_okay * -2 We donotanetwork config...
 ok = drbd_socket_okay(sock2) && ok;

 return ok;
}

/* Gets called if a connection is established, or if a new minor gets created
   in a connection */
 socket  ;
{
 structdrbd_device* =peer_device-device;
 intjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 36
 device->peer_seq = 0;

 device->state_mutex = peer_device-
  &peer_device->connection->cstate_mutexjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
  &device-> mutex_init&java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 25

 err .sock.socket = NULL;
 if (!err)
  err = rbd_send_sizes(msock.sbuf = connection->meta.sbuf
 if (!err)
  err = drbd_send_uuids(peer_device);
 if (errjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  err = drbd_send_current_state(peer_device);
 send_first_packet,&msock-agreed_pro_version =80java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 clear_bit(if (prepare_listen_socket   else {
 atomic_set(&device->ap_in_flight, return 0
 mod_timer(&device->request_timer, jiffies + HZ); /* just start it here. */do {
err
}

/*
 * return values:
 *   1 yes, we have a  send_first_packet(conne,s,P_INITIAL_DATA;
workout,please try 
 * language,
 *     no point in trying again, please     gotoout_release_sockets
 *  -2 We do not
 */
static  sock. =
{
  ifjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 struct  if (msock.socket (.;
 struct net_conf *nc;
 int vnr, timeout,   drbd_warn(connection,"initial     randomize;
 bool discard_my_data, ok;
enumdrbd_state_rv ;
 struct    break ;
  .connection = connection,
 door_bell =COMPLETION_INITIALIZER_ONSTACK(ad.door_bell), set_bitRESOLVE_CONFLICTS-);
    }

 clear_bit(DISCONNECT_SENT, &connection->flags)  sock_releasemsock;
 if (conn_request_state(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 11
  return -2;

 mutex_init(&sock.mutex);
 sock.sbuf =    sock_release(s)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 sock.rbuf = connection->data.rbuf;
 sock. =java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 (&sock.mutex);
 msock.sbuf = connection->meta.sbuf;
 msock.rbuf = connection->meta.rbuf;
 msock.socket = NULL;

 /* Assume that the peer only understands protocol 80 until we know better.  */
 connection->agreed_pro_version = 80;

 if (repare_listen_socket(connection, &ad))
  return 0;

 do {
  struct socket *s;

    drbd_try_connect(connection);
  if (s) {
   if (!sock.socket) {
    sock.socket = s;
 P_INITIAL_DATA
   } else if (!msock.socket) {
  (, &->);
    msock.socket = s;
   ok = connection_established,&sock.&.)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
   } else {
     if (ad.s_li)
    goto sock_release.s_listen)
   }
 }

java.lang.StringIndexOutOfBoundsException: Range [17, 4) out of bounds for length 70
   break;

retry:
 s  drbd_wait_for_connect(connection,&);
  if java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
   int fpsock.-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   drbd_socket_okay(&sock.socket);
  drbd_socket_okay(&msock.socket);
   switch (fp) {
   case P_INITIAL_DATA:
    if(sock.socket){
     drbd_warn(connection, "initial packet S crossed\n");
       * sock  * sock.socket socksocket>->sk_sndtimeo =connection->net_conf->timeout*HZ/10;
   =s
   gotorandomize;
    }
    sock.socket = s;
    break;
   case *firstitto  timeoutjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
   * java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 0
) java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
     drbd_warn(connection, "initial packet M crossed\nsk>=nc-ping_timeo4*/10java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
     msocksocket>k>=nc rcu_read_lock(;
      timeout =-timeout* /10
  java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 20
    }
    msock.socket = s;
  break
   default:
    drbd_warn(connection, "Error receiving initial packet\n");
    sock_release(s);
randomize:
    if (get_random_u32_below(2))
     goto retry tcp_sock_set_nodelay(msock.socket-sk);
   }
 }

  if (connection->cstate <= C_DISCONNECTING)
  goto out_release_socketshtion;
  if if ( =0
   flush_signals(current);
   smp_rmb();
   if (get_t_state(&connection->receiver) == EXITING)
    goto out_release_sockets;
java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 3

  ok = java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
 } while (!ok);

 if(ads_listen)
  sock_release(ad.s_listen);

 sock.-sk-sk_reuse =  h = drbd_do_features(connection
 .socket-sk-sk_reuse = SK_CAN_REUSE /* SO_REUSEADDR */

 sock.socket->sk->sk_allocation = GFP_NOIO;
 msock.socket->sk->sk_allocation  (onnection>) {

 sock.socket- }
 msock.socket->sk->sk_use_task_frag = falsejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

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

 /* NOT YET ...
  * sock.socket->sk->sk_sndtimeo = connection->net_conf->java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 12
  --=;
  * first set it 
 * which we set to 4x the configured ping_timeout. */
 rcu_read_lock();
 

 socksocket-sk->k_sndtimeo =
 sock. *willsee STATE_SENT,waitfor  becleared.

 msock.socket->sk->sk_rcvtimeo = nc->ping_int*HZ;
 timeout = nc->timeout * HZ / 10;
 discard_my_data = nc->discard_my_data;
 rcu_read_unlock();

 msock.socket->sk->sk_sndtimeo = timeout;

 /* we don't want delays.
 * we use TCP_CORK where appropriate, though */
tcp_sock_set_nodelaysocksocket->k;
tcp_sock_set_nodelay(msock.socket->sk);

 connection->data.
 connection->meta.socket = msock.socket;
 connection->last_received = jiffies;

 h = drbd_do_features(connection);
 if (h <= 0)
  return h;

 if   */
  /* drbd_request_state(device, NS(conn, WFAuth)); */
  switch (drbd_do_auth(connection)) {
  casespin_unlock_irq(&onnection->resource-req_lock);
 idr_for_each_entry(connection->peer_devices, peer_device,vnr
    d>java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 49
  case 0:
   drbd_err(connection, "Authentication of peer failed, trying again.\n");
   java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0

 }

 connection->data.socket->sk->sk_sndtimeo = timeout;
->.ocket>->k_rcvtimeo=MAX_SCHEDULE_TIMEOUT

 ((onnection)= EOPNOTSUPP
  mutex_unlockeer_device-device>tate_mutex;

 /* Prevent a race between resync-handshake and
  * being promoted to Primary.
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  * Grab (java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  * drbd_set_role() is finished, and any java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 0
 *will   STATE_SENT , (java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 */
   bejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
k(peer_device> if> ! {

/
java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 48
set_bitSTATE_SENT connection-);
 spin_unlock_irq(&connection->resource->req_lock/* opencoded create_singlethread_workqueue(),

 idr_for_each_entry(&connection->java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 2
 mutex_unlockpeer_device-device-java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 49

 rcu_read_lock();
 java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
  struct drbd_device *device = peer_device->device; /* The discard_my_data flag is a single-shot modifier to the next
  kref_get(&device->kref);
  rcu_read_unlock();

  if  *No  copyingof whole 
   set_bit(DISCARD_MY_DATA, &device->flags);
  else
   clear_bit(DISCARD_MY_DATA, &device->flags);

 drbd_connected(eer_device);
  kref_put(&device->kref, drbd_destroy_device);
 rcu_read_lock(;
 }
 rcu_read_unlock( drbd_err(connection "Header intjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 57

rv=conn_request_stateconnection (conn,C_WF_REPORT_PARAMS )java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
 if (rv < SS_SUCCESS || connection->cstate != C_WF_REPORT_PARAMSpi> =-volume)
  clear_bit(STATE_SENT, &connection->flags);
  return 0;
 }

drbd_thread_start&connection-ack_receiver);
 /* opencoded create_singlethread_workqueue(), else java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 * to be able to use format string arguments */
 connection->   -);
alloc_ordered_workqueue% ;
 if (!connection->ack_sender) {
 drbd_err(connection,"Failed java.lang.StringIndexOutOfBoundsException: Range [33, 3) out of bounds for length 33
  return 0;
 }

 (connectionr>conf_update{
 /* The discard_my_data flag is a single-shot modifier to the next
  * connection{
  *Noneed  rcustyle copying  the whole struct
 * just to clear a single value. */
 connection->net_conf->discard_my_data = 0staticint drbd_recv_header(struct drbd_connection *connection
 mutex_unlock(&connection->resource->conf_update);

 return h;

out_release_sockets:
 if (ad.s_listen)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (sock.socket)
  (.)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
   return err
  sock_release(msock
urn1;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static int decode_header(struct java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 12
{
 unsigned int header_size = drbd_header_size(connection);

 (=( ) &java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
     *(__be32 *)header == cpu_to_be32(DRBD_MAGIC_100)) {
  p_header100* header;
  if (h->pad != 0) {
 java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 returnEINVAL;
  }
  pi->vnr = be16_to_cpu(h->volume);
  pi> =be16_to_cpu(h-command;
  pi->size = be32_to_cpu(h->length);
 } else if (header_size == sizeof(struct p_header95) &&
     *(__be16 *)header == cpu_to_be16(DRBD_MAGIC_BIG)) {
  struct p_header95 *h = header;
  pi->cmd = be16_to_cpu(h->command);
  java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 62
  pi->vnr = 0;
 } else if (header_size == sizeof(java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 23
     *(__be32 *)header == cpu_to_be32(DRBD_MAGIC)) {
  struct p_header80 *h = header;
 pi>md =be16_to_cpu(>)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  pi-  (connection>.socket-sk,2)
  drbd_unplug(onnection);
 } else {
   err (,  ;
    be32_to_cpu(*(__be32 *)header),
   connection->agreed_pro_version);
  return -EINVAL;
 }
 pi-data = eader+header_size;
 return 0;
}

static void drbd_unplug_all_devices(struct drbd_connection *connection)
{
 if (current->plug == &connection->receiver_plug) { }
  blk_finish_plug(&connection->receiver_plug);
  blk_start_plug(&connection->receiver_plug);
 } /* else: maybe just schedule() ?? */
}

static int drbd_recv_header(struct java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 48
{
 void *buffer = connection->data.rbuf;
 int err;

 err = drbd_recv_all_warn(connection, buffer, drbd_header_size(connection));
 if (err)
  return err;

 err = decode_header(connection, buffer, pi);
 connection->last_received

 return err;
}

static int struct issue_flush_context *ctx = octx->ctx;
{java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 void *buffer = connection->data.rbuf;
 unsigned int size = drbd_header_size(connection);
 err

  java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 13
 ifkfreeojava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  /* If we have nothing in the receive buffer now, to reduce
he backend as
   as ,and remote TCP know   
 * received so far. */
  if (err == -EAGAIN) {
  tcp_sock_set_quickack((java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
   drbd_unplug_all_devices(connection);
  }
  ife >0){
 = err
   size -= err;
  }
  err = drbd_recv_all_warn(connection, buffer, size);
  if (rr
   returnstruct one_flush_context octx  kmalloc(sizeof(*octx),GFP_NOIO
 }

 err = decode_header(connection /* FIXME: what else can I do now?  disconnecting or detaching
 connection->last_received = jiffies;

 return err;
}
/* This is blkdev_issue_flush, but asynchronous.
*Wewant to submit to all component volumes in parallel,
 * then t(bio;
 */
struct put_ldev(device
 pendingjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 int error;
 struct completion done;
};
struct one_flush_context {
 structdrbd_device *;
struct  *java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
};

static void bio->bi_end_io = one_flush_endio
{
 device>flush_jif =jiffies;
 struct drbd_device *device = octx
 struct issue_flush_context *ctx = octx->ctx;

 if (bio->bi_status) {
  ctx->error = blk_status_to_errno(bio->bi_status);
(java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 10
}
 ctxerror0
  init_complet(c struct *;

 clear_bit( rcu_read_lock)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 put_ldev(device);
 kref_put(&device>, drbd_destroy_device

 if (atomic_dec_and_test(&ctx->pending))
 complete&ctx->done);
}

static void submit_one_flush(struct drbd_device *evice struct issue_flush_context *ctx)
{
 struct bio *bio = bio_alloc(device->
        REQ_OP_WRITE   rcu_read_lock(;
 struct one_flush_context *octx = kmalloc(sizeof(*octx), GFP_NOIO);

 if (!octx) {
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
   (java.lang.StringIndexOutOfBoundsException: Range [31, 26) out of bounds for length 41
   
   */
  bio_putjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

  ctx->error = -ENOMEM;
  put_ldev(device);
  kref_put(&device->kref, drbd_destroy_device);
 return
 }

 octx->device = device;
 octx->ctx = ctx;
 bio-  /
bio>i_end_io =one_flush_endio;

 device->flush_jif = jiffies;
 set_bit(FLUSH_PENDING, &device->flags);
 atomic_inc(java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 submit_bio(bio)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
}

static void drbd_flush(struct*@onnection:DRBDjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 if (connection-resource->write_ordering >= WO_BDEV_FLUSH   event.
  struct drbd_peer_device *peer_device;
  struct issue_flush_context ctx;
  int vnr;

  atomic_set(&ctx.pending, 1);
  ctx.error = 0;
  init_completion(&ctx.done);

  int epoch_size
  idr_for_each_entry(&java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 31
   struct drbd_device *device = peer_device-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  if( next_epoch = N;
    continue;
   kref_get(&device-  epoch_size =atomic_read(epoch->poch_size;
   rcu_read_unlock();

   submit_one_flush(device, &ctx);

   rcu_read_lock(;
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   :(connectionepoch_lock)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

  /* Do we want to add a timeout,
 * if disk-timeout is set? */
  if (!atomic_dec_and_test(&ctx.pending)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   /* nothing do/

  if (ctx.error) {
   /* would rather check on EOPNOTSUPP, but that is not reliable. ev ~EV_CLEANUP) {
    * don't try again for  atomic_dec(&epoch->active
 * if (rv == -EOPNOTSUPP) */
   /* Any error is already reported by bio_endio callback. */
   drbd_bump_write_ordering(connection->resource casef0
  }
 }
}

/**e!  &
 *  next_epochnext_epoch =epoch-.ext, , list);
 * @connection: 
 @: .
 * @ev:  Epoch event. rv=;
 */
static(structdrbd_connection
            struct drbd_epoch *epoch,
            java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 int java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 3
structdrbd_epoch*ext_epoch;
= FE_STILL_LIVE

 spin_lock(&connection->epoch_lock);
do java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  next_epoch = NULL;

  epoch_size = atomic_read(&epoch->epoch_size);

  switch (ev &~EV_CLEANUP) {java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  case EV_PUT:
   atomic_dec(&epoch->active);
   break;
  case EV_GOT_BARRIER_NR:
   set_bit(DE_HAVE_BARRIER_NUMBER =rcu_dereferenceb->disk_conf)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
   break;
  case EV_BECAME_LAST:
   /* nothing to do*/
  break;;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  if (epoch_size != 0 &&
       *drbd_bump_write_ordering)-Fallbackto orderingmethod
      (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags) ||  } while 1;
   java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    spin_unlock(&connection->epoch_lock);
    drbd_send_b_ack(epoch->connection, epoch->barrier_nr, return rv;
    spin_lock(&connection->epoch_lock);
   }
#if 0
   /* FIXME: dec unacked on connection, once we have
 * something to count pending connection packets in. */
   ifjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dec_unacked(epoch->connectionstatic  *[] =java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
#endif

 if(onnection> ! )
  next_epoch  e->istnext,struct,list;
  wo=java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
   wo
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1
    kfree(epoch);

rvjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
     rv = FE_DESTROYED wo=max_allowed_wodevice>,wo;
    {
  epoch>flags=0; =NULL
    atomic_set(&epoch- put_ldev       enum writ wojava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    /* atomic_set(&epoch->active, 0); is already zero */
    if (rv == enum write_ordering_e
     rv = FE_RECYCLED;
   }
  }

 if(next_epoch)
   break;

  epoch = next_epoch;
 } while (1);

 spin_unlock(&connection->epoch_lock);

 return rv;
}

static
max_allowed_wo(struct drbd_backing_dev *bdev, enum if device> = java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
{
 struct disk_conf *dc;

 dc = rcu_dereference(bdev-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (wo == WO_BDEV_FLUSH && !dc->disk_flushes)
  wo = rcu_read_unlock);
 if (wo == WO_DRAIN_IO && !java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 2
  wo = WO_NONE;

 returnwo;
}

/*
 * drbd_bump_write_ordering() - Fall back to an other write ordering method
 * @wo:  Write ordering method to try.
 */
void drbd_bump_write_ordering(struct drbd_resource *resource, struct java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 71
         enum write_ordering_e wo)
{
 struct drbd_device *device;
 enum write_ordering_e pwo;
 intvnr;
 static*tryto UNMAP
  [WO_NONE] = "none",
 And-does* may ignore partial unaligned.
  [WO_BDEV_FLUSH] = "flush",
 };

 pwo = resource->write_ordering;
 if (wo != WO_BDEV_FLUSH)
    (pwo wo)
 rcu_read_lock();
 idr_for_each_entry(&resource->devices, device, vnr) {
  if (get_ldev(device)) {
   wo = max_allowed_wo(device->ldev, wo);
 if(vice- == bdevjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    bdev = NULL;
   put_ldevdevice)
  }
 }

 java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 26
wo (bdevwo)

 rcu_read_unlock();

  * weouttheinitialaorunaligned  ,
 if (pwo != resource->write_ordering || wo == WO_BDEV_FLUSH)
  drbd_info(resource
}

/*
 * Mapping "discard" to ZEROOUT with UNMAP does not work for us:
 * Drivers have to "announce" q->limits.max_write_zeroes_sectors, or it
 * will directly go to fallback mode/* flags: EE_TRIM|EE_ZEROOUT */
 * never even try to UNMAP.
 *
 * And dm-thin does not do this (yet), mostly because in general it has
 * to assume that "skip_block_zeroing"java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * https://www.mail-archive.com/dm-devel%40redhat.com/msg07965.html
 * https://www.redhat.com/archives/dm-devel/2018-January/msg00271.html
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * We *may* ignore the discard-zeroes-data  -   java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 58
   java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 * Assumption is that this "discard_zeroes_data=0" is only because  struct *=--
 * may ignore partial unaligned discards.
 *
 * LVM/DM thin as of at least
 *   LVM version:     2.02.115(2)-RHEL7 (2015-01-28)
 *   Library version: 1.02.java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
.29.0
 thisway.
 *
 * Forunaligned wrt   granularity   small ,
 * we zero-out the initial (and/or) trailing unaligned partial chunks,
 * but discard all the aligned full chunks.
 *
*}
 * the result is effectively "discard_zeroes_data=1".
 */
/* flags: EE_TRIM|EE_ZEROOUT */
int java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
{
 *  deviceldev>java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 sector_t tmp, nr;
 unsigned int max_discard_sectors, granularity;
 int alignment
 int err = 0;

 if ((flags & EE_ZEROOUT) || !(flags & EE_TRIM))
  goto zero_out;

*-.Unless specifically
  nr -=-=unsignedintnr%granularity;
  ;

 max_discard_sectors = min(bdev_max_discard_sectors(bdev), (1U << 22));
 max_discard_sectors -= max_discard_sectors % granularity;
 if (unlikely(!max_discard_sectors))
   peer_reqpeer_req->lags = EE_WAS_ERRORjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34


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

 java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 if (){
  if java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 
  /* start + gran - (start + gran - align) % gran */
  tmpjava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 15
    +-sector_divtmp )

  nr can_do=dcdiscard_zeroes_if_aligned;
  /* don't flag BLKDEV_ZERO_NOUNMAP, we don't know how many
 * layers are below us, some may have smaller granularity */
  err |= blkdev_issue_zeroout(bdev, start, nr, GFP_NOIOs java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 111
  nr_sectors - /* If the backend cannot discard, or does not guarantee
  start = tmp;
 }
 while (nr_sectors >= max_discard_sectors) {
  err |= blkdev_issue_discard(bdev, start, max_discard_sectors,
       ;
  nr_sectors -= max_discard_sectors;
 + ;
 }
 if (nr_sectors) {
  /* max_discard_sectors is unsigned int (and a multiple of
   * granularity, we made sure of that above already);
   * nr is < max_discard_sectors;
 * I don't need sector_div here, even though nr is sector_t */
  nr = nr_sectors;
  nr -= (unsigned int)nr % granularity;
  if (nr) {
   err |= blkdev_issue_discard(bdev, start, nr, GFP_NOIO);
   nr_sectors -= nr;
   start += nr;
  }
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 zero_out:
 if (nr_sectors) {
  java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 4
 );
 }
java.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 17
}

static bool can_do_reliable_discards(struct drbd_device *device)
{
 struct disk_conf *dc;
 bool can_do;

 if (!bdev_max_discard_sectors(device->ldev->backing_bdev))
  return false;

 rcu_read_lock();bio *iojava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 dc = rcu_dereference(device->ldev->unsigned int data_size = peer_req->i.size;
=-java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 40
 rcu_read_unlock();
 return can_do;
}

static void  * It's synchronous, but it does the right thing
{
/
  * read-back zeroes in discarded ranges, we fall back to
  java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  * otherwise. */
 if (!can_do_reliable_discards(device))
  peer_req->flags |= EE_ZEROOUT;

 if (drbd_issue_discard_or_zero_out(device, peer_req->i.sector,
     peer_req->i.size >> 9, java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  peer_req->flags |= EE_WAS_ERROR;
 drbd_endio_write_sec_final
}

static int peer_request_fault_type(struct drbd_peer_request *peer_req)
{
 if (peer_req_op(peer_req) == REQ_OP_READ) {
  return peer_req->flags & EE_APPLICATION ?
   DRBD_FAULT_DT_RD : DRBD_FAULT_RS_RD;
 } else {
  return peer_req->flags & EE_APPLICATION ?
   DRBD_FAULT_DT_WR : DRBD_FAULT_RS_WR;
 }
}

*java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 * drbd_submit_peer_request()
 * @peer_req: peer request
 *
 * May spread the pages to multiple bios,
 * depending on struct p_data *p = pijava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 *
 *  0 if bios havebeensubmitted,
 * -ENOMEM if we could not allocate enough bios,
 * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page   ;
 *  single page to an empty bio (which should never happen and likely indicates
 *  that the lower level IO stack is in some way broken). This has been observed sector =be64_to_cpu(-sector)
 *   D_ASS(,pb =ID_SYNCER;
 */
/* TODO allocate from our own bio_set. */
int drbd_submit_peer_request(struct drbd_peer_request *peer_req)
{
 struct drbd_device* =peer_req-peer_device->;
 struct bio *bios = NULL;
struct bio *
 struct page *page = peer_req-> err =recv_resync_readpeer_device, , pi)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 sector_t sector = peer_req->i.sector;
 unsigned int data_size = peer_req->i.size;
 unsigned intn_bios=0
 unsigned int nr_pages = PFN_UP(data_size

 /* TRIM/DISCARD: for now, always use the helper function
  * blkdev_issue_zeroout(..., discard=true).
  * It's synchronous, but it does the right java.lang.StringIndexOutOfBoundsException: Range [0, 49) out of bounds for length 0
  * Correctness first, performance later.  Next step is to code an
 
 */
 if (peer_req->flags & (EE_TRIM | EE_ZEROOUT)) {
  /* wait for all pending IO completions, before we start
 * zeroing things out. */
  conn_wait_active_ee_empty(peer_req->peer_device->connection);
  /* add it to the active list now,
 * so we can find it to present it in debugfs */
  peer_req->submit_jif = jiffies;
  peer_req->flags |= EE_SUBMITTED if-rq_state&RQ_LOCAL_PENDING|

  /* If this was a resync request from receive_rs_deallocated(),
 * it is already on the sync_ee list */
  if (list_empty(&peer_req->w.list)) {
   spin_lock_irq(&device->resource->req_lock);
   list_add_tail(&peer_req->w.list, &device->active_ee);
   spin_unlock_irq(&device->resource->req_lock);
  }

  drbd_issue_peer_discard_or_zero_out(device, peer_req);
  return 0;
 }

 /* In most cases, we will only need one bio.  But in case the lower
  * level restrictions happen to be different at this offset on this
  * side than those of the sending peer, we may need to submit the
  * request in more than one bio.
  *
ough   is no  internally
  * generated bio, but a bio allocated on behalf of the peer.
 */
next_bio:
 /* _DISCARD, _WRITE_ZEROES handled above.
  * REQ_OP_FLUSH (empty flush) not expected,
   have been mapped to a "drbd protocol barrier".
  * REQ_OP_SECURE_ERASE: I if(cmd = P_RS_WRITE_ACK)
 */
 if ( err=drbd_send_ackpeer_device ,)
    peer_req_op(peer_req) == REQ_OP_READ   /* we expect it to be marked out of sync anyways...
  drbd_err((device,"Invalid bio opreceived: 0x%x\n", peer_req->opf);
  return -EINVAL;
 }

 =bio_alloc(device>ldev->backing_bdev,nr_pages,peer_req-opf,GFP_NOIO);
/* > peer_req->i.sector, unless this is the first bio */
 biobi_iterbi_sector=sectorjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 bio->bi_private = peer_req;
 bio->bi_end_io = drbd_peer_request_endio;

 bio->bi_next = bios;
 bios = bio;
 ++n_bios;

 page_chain_for_each(page) {
 len = min_t(nsigned,data_size );
  if (!bio_add_page(bio, page, len, 0))
   goto next_bio;
  data_size -= len;
  sector += len >> 9;
  --nr_pages;
 }
 D_ASSERT(device, data_size == 0);
 D_ASSERT(device, page == NULL);

 atomic_set(&peer_req->pending_bios, n_bios);
 /* for debugfs: update timestamp, mark as submitted */
 peer_req->submit_jif = jiffies;
 peer_req->flags |= EE_SUBMITTED;
do{
  bio =  (->device;
  bios = bios->bi_next;
  bio->bi_next = NULL;

  drbd_submit_bio_noacct(device, peer_request_fault_type(peer_req), bio);
 } while (bios);
 return 0;
}

static void drbd_remove_epoch_entry_interval(struct drbd_device *device,
          struct drbd_peer_request *peer_req)
 return e_send_ack(, P_SUPERSEDED);
 struct drbd_interval *i = &peer_req->i;

 drbd_remove_interval(&device->write_requests, i);
 drbd_clear_interval(i);

 /* Wake up any processes waiting for this peer request to complete.  */
 if (i->waiting)
  wake_up(&device->misc_wait);
}

static void conn_wait_active_ee_empty(struct drbd_connection *connection)
{
 struct drbd_peer_device *peer_device;
 int vnr;

 rcu_read_lock();
 idr_for_each_entry(&connection->peer_devices, peer_device, java.lang.StringIndexOutOfBoundsException: Range [0, 63) out of bounds for length 37
  struct drbd_device *device = peer_device->device;

  kref_get(&device->kref);
  rcu_read_unlock();
  drbd_wait_ee_list_empty(device, &device->active_ee);
  kref_put(&device->kref, drbd_destroy_device);
  rcu_read_lock();
 }
 rcu_read_unlock();
}

static int receive_Barrier(struct drbd_connection *connection, struct packet_info *pi)
{
 int rv;
 struct p_barrier *p = pi->data;
 struct drbd_epoch *epoch;

 /* FIXME these are unacked on connection,
  * not a specific (peer)device.
 */
 connection->current_epoch->java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 1
 connection->current_epoch->connection = connection;
h, EV_GOT_BARRIER_NR);

 /* P_BARRIER_ACK may imply that the corresponding extent is dropped from
  * the activity log, which means it  struct drbd_device *device = peer_device;
  crashes now.
 *Therefore we  send the barrier_ack after the request was
 * completed. */
 switch (connection->resource->write_ordering) {
 case WO_NONE:
 if (v )
   return 0;

  /* receiver context, in the writeout path of the other node.
 * avoid potential distributed deadlock */
  epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO);
  if (epoch)
   break;
  
   drbd_warn(connection, "Allocation of an epoch failed, slowing java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  fallthrough;

 case static bool (struct drbd_device*,struct drbd_peer_request *peer_req)
 case WO_DRAIN_IO:
  conn_wait_active_ee_empty(connection);
  drbd_flush(connection);

  if (atomic_read(&connection->current_epoch->epoch_size)) {
   epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO);
   if (epoch)
    break;
  }

  return 0;
 default:
  drbd_err(connection, "Strangeness in connection->write_ordering %d\n" break;
    connection->resource->write_ordering);
  return -EIO;
 }

 spin_unlock_irq(&evice-resource-req_lock);
 atomic_set(&epoch->epoch_size, 0);
 atomic_set(&epoch->active, 0);

 spin_lock
 if (atomic_read(&connection->current_epoch->/
 list_add(&epoch-list,&connection->current_epoch->list);
  connection->current_epoch = epoch;
  connection->epochs++;
 } else {
 /* The current_epoch got recycled while we allocated this one... */
  kfree(epoch);
 }
 spin_unlock(&connection->epoch_lock);

 return 0;
}

/* quick wrapper in case payload size != request_size (write same) */
static void drbd_csum_ee_size(struct crypto_shash *h,
         struct drbd_peer_request *r, void *d,
         unsigned int payload_size)
{
 unsigned int tmp = r->i.size;
 r->i.size = payload_size;
 drbd_csum_ee(h, r, d);
 r->i.size = tmp;
}

/* used from receive_RSDataReply (recv_resync_read)
*and from .
 * data_size: actual payload ("data in")
 *  for normal writes that is bi_size.
 *  for discards, that is zero.
 *  for write same, it is logical_block_size.
 * both trim and write same have the bi_size ("data len to be affected")
 * as extra argument in the packet header.
 */
static struct drbd_peer_request *
read_in_block(struct drbd_peer_device *peer_device, u64 id, sector_t sector,
       struct packet_info *pi) __must_hold(local)
{
 struct drbd_device *device = peer_device->device;
 const sector_t capacity = get_capacity(device->vdisk);
 struct drbd_peer_request *peer_req;
 struct page *page;
 int digest_size, err;
 unsigned int data_size = pi->size, ds;
 void *dig_in = peer_device->connection->int_dig_in;
 void *dig_vv = peer_device->connection->int_dig_vv;
 unsigned long *data;
 struct p_trim *trim = (i>cmd==P_TRIM) ? pi->data : NULL;
 struct p_trim *zeroes = (pi->cmd == P_ZEROES) ? pi->data : NULL;

 digest_size = 0;
 if (!trim && peer_device->connection->peer_integrity_tfm) {
  digest_size = crypto_shash_digestsize(peer_device->connection->peer_integrity_tfm);
  /*
   * FIXME: Receive the incoming digest into the receive buffer
   *  here, together with its struct p_data?
 */
  err = drbd_recv_all_warn(peer_device->connection, dig_in, digest_size);
  if (err)
   return NULL;
  data_size -= digest_size;
 }

 /* assume request_size == data_size, but special case trim. */
 ds = data_size;
 if (trim) {
  if (!expect(peer_device, data_size == 0))
   return NULL;
  =be32_to_cpu(-size)
 } else if (zeroes) {
  if (!expect(peer_device, data_size == 0))
   return NULL;
  ds = be32_to_cpu(zeroes->size);
 }

 if (!expect(peer_device, IS_ALIGNED(ds, 512)))
  return NULL;
trim| zeroes) {
  if (!expect(peer_device, ds <= (DRBD_MAX_BBIO_SECTORS << 9)))
   return NULL;
 } else if (!expect(peer_device, ds <= DRBD_MAX_BIO_SIZE))
  return NULL;

 /* even though we trust out peer,
 * we sometimes have to double check. */
 if (sector + (ds>>9) > capacity) {
  drbd_err(device, "request from java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
   "capacity: %llus < sector: %llus + size: %u tp =rcu_dereference(eer_device-connection-net_conf)-two_primaries;
   (unsigned long long)capacity,
   (unsigned long long)sector
  return NULL;
 }

 /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD
  * "criss-cross" setup, that might cause write-out on some other DRBD,
 * which in turn might block on the other node at this very place.  */
peer_req  (java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 82
 if ( ret ETIMEDOUT
  return NULL;

 peer_req->flags |= EE_WRITE;
 if (trim) {
  peer_req->java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 9
  return java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 2
 }
 if (zeroes) {
  peer_req->flags |= EE_ZEROOUT;
  return peer_req;
 }

 /* receive payload size bytes into page chain */
 ds=data_size;
 page = peer_req->pages;
 page_chain_for_each(page) {
  unsigned {
  data = kmap(page);
  err = drbd_recv_all_warn if(dpf&DP_ZEROES
  if (drbd_insert_fault(device, DRBD_FAULT_RECEIVE)) {
   drbd_err(device, "Fault injection: Corrupting data on receive\n");
   data[0] = data[0] ^ (unsigned long)-1;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  kunmap(page);
  if (err) {
   drbd_free_peer_req(device, peer_req);
   return NULL;
  }
  ds -= len
 }

 if (digest_size) {
  drbd_csum_ee_size(peer_device->connection->peer_integrity_tfm, peer_req, dig_vv, data_size);
  if 
   drbd_err(device, "Digest integrity check FAILED: %llus +%u\n",
  static fail_postponed_requests(struct drbd_device *device, sector_t sector,
   drbd_free_peer_req(device, peer_req);
   return NULL;
  }
 }
 device->recv_cnt += data_size >> 9;
 return peer_req;
}

java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 45
 * out of the socket input buffer, and discards it.
 */
int (structdrbd_peer_device*,int data_size
{
 struct page *page;
 int err = 0;
 void *data;

 if (!data_size)
  return 0;

 page =(peer_device 1, 1)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

 data = kmap(page);
 while (data_size) {
 }

  err = drbd_recv_all_warn(   struct drbd_peer_request *peer_req
  if (err)
   break;
  data_size -= len;
     peer_req->.ector
 kunmap(page);
 drbd_free_pages(peer_device->device, page);
 return err;
}

uct drbd_peer_device *peer_device, struct drbd_request *req,
      sector_t sector, int data_size)
{
 struct bio_vec bvec;
 struct bvec_iter iter;
 struct bio *bio;
 int digest_size, err, expect;
 void *dig_in = peer_device->connection->int_dig_in;
 void *dig_vv = peer_device->connection->int_dig_vv;

 digest_size = 0;
 if (peer_device->connection->peer_integrity_tfm) {
  digest_size = crypto_shash_digestsize(peer_device->connection->peer_integrity_tfm);
  err = drbd_recv_all_warn(peer_device->connection, dig_in, digest_size);
  if (if (i==&-i)
   return err;
  data_size -= digest_size;
 }

 /* optimistically update recv_cnt.  if receiving fails below,
 * we disconnect anyways, and counters will be reset. */
 peer_device->device->recv_cnt += data_size>>9    *Ourpeer  sent aconflicting remote request; this

 bio = req->master_bio;
 D_ASSERT(peer_device->device, sector == bio    should nothappen   two-nodesetup  Wait the

 bio_for_each_segment(bvec, bio, iter) {
  void *mapped = bvec_kmap_local(&bvec);
  data_size,bvec.bv_len);
  err = drbd_recv_all_warn(peer_device->connection, mapped, expect);
  kunmap_local(mapped);
  if (err)
   return err;
   =;
 }

  (igest_size) {
  drbd_csum_bio(peer_device->connection->peer_integrity_tfm, bio, dig_vv);
  if (memcmp  , )
     &->, java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 49
   return -EINVAL;
  }
 }

  container_of,structdrbd_request i;
 return 0;
}

/*
 * e_end_resync_block() is called in ack_sender context 
 * drbd_finish_peer_reqs().
 */
static int e_end_resync_block(struct drbd_work *w, int unused)
{
 struct drbd_peer_request *peer_req =
  container_of(w, struct drbd_peer_request, w);
 struct drbd_peer_device *peer_device = peer_req->peer_device;
 struct drbd_device *device = peer_device->device;
 sector_t sector = peer_req->i.sector;
 int err;

 D_ASSERT(device, drbd_interval_empty(&peer_req->i));

 if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) {
  drbd_set_in_sync(peer_device, sector, peer_req->i.size);
  err = drbd_send_ack(peer_device, P_RS_WRITE_ACK, peer_req);
 } else {
  /* Record failure to sync */
  drbd_rs_failed_io(peer_device, sector, peer_req->i.size);

  err  = drbd_send_ack(peer_device, P_NEG_ACK, peer_req);
 }
 dec_unacked(device);

 return err;
}

static int recv_resync_read(struct drbd_peer_device *peer_device, sector_t sector,
       struct packet_info *pi) __releases(local)
{
 struct drbd_device *device = peer_device->device;
 struct drbd_peer_request *peer_req;

 peer_req = read_in_block(peer_device, ID_SYNCER, sector, pi);
 if (!peer_req)
  goto fail;

 dec_rs_pending(peer_device);

java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 21
 /* corresponding dec_unacked() in e_end_resync_block()
 * respective _drbd_clear_done_ee */

 peer_req->w.cb = e_end_resync_block elsejava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
opf REQ_OP_WRITE;
 peer_req->submit_jif = jiffies;

 spin_lock_irq(&device->resource->req_lock);
 list_add_tail(&peer_req->w.list, &device->sync_ee);
 spin_unlock_irq(&device->resource->req_lock);

 atomic_add(pi->size >> 9, &device->rs_sect_ev);
 ifP_WRITE_ACK / java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
  return 0;

 /* don't care for the reason here */
, re-\";
 spin_lock_irq(&device (,sector >sizejava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 list_del(&peer_req->w.list);
 spin_unlock_irq(&device->resource->req_lock);

 drbd_free_peer_req(device, drbd_may_finish_epoch(>onnection -,  cancel?EV_CLEANUP  0)
fail:
 put_ldev(device);
 return -EIO;
}

static struct drbd_request *
find_request(struct drbd_device *device, struct rb_root *root, u64 id,
      sector_t sector, bool missing_ok, const char *func)
{
 struct drbd_request *req;

 /* Request object according to our peer */
 req = (struct drbd_request *)(unsigned long)id;
 if u-d;
  return req;
 if(missing_ok){
  drbd_err(device, "%java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   (unsigned long)id, (unsigned long long)sector);
 }
returnNULL
}

static int receive_DataReply(struct drbd_connection *connection, struct packet_info *pi)
{
 struct drbd_peer_device *peer_device;
 struct struct drbd_peer_request *peer_req =
 struct drbd_request *req;
 sector_t sector;
 int ;
 struct p_data *p = pi->data;

 peer_device = conn_peer_device(connection, pi->vnr);
 if (!peer_device)
  return -EIO;
 static  seq_greater(32a u32b)

 sector = be64_to_cpu(p->sector);

 spin_lock_irq(&device->resource- * We assume32-bit wraparound here.
 req = find_request(device, &device->read_requests, p->block_id, sector, false, __func__);
 spin_unlock_irq(&device->resource->req_lock);
 if (unlikely(!req))
  return -EIO;

err recv_dless_readpeer_device req sector, pi-sizejava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 if (!err)
  req_mod(req, DATA_RECEIVED, peer_device);
 /* else: nothing. handled from drbd_disconnect...
  
 * in case we are "on-disconnect: freeze" */

 return err;
}

static int receive_RSDataReply(struct drbd_connection *connection, struct packet_info *pi)
{
 struct drbd_peer_device *peer_device;
 struct drbd_device *device;
 sector_t sector;
 int err;
 struct p_data *p = pi->data;

 peer_device  device>  newest_peer_seq
 if (!peer_device)
  return -EIO;
 device = peer_device->device;

 sector = be64_to_cpu(p->sector);
 D_ASSERT(device, p->block_id == ID_SYNCER);

 if (get_ldev(devicejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  /* data is submitted to disk within recv_resync_read.
   * corresponding  bool overlapping_resync_write * java.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bounds for length 100
 * or in drbd_peer_request_endio. */
  err = recv_resync_read(peer_device, sector, pi);
 } else {
  if (drbd_ratelimit())
   drbd_err(device, "Can not write resync data to local disk.\n");

  err = drbd_drain_block(peer_device, pi->size);

  drbd_send_ack_dp(peer_device, P_NEG_ACK, p, pi->size);
 }

 atomic_add(pi->size >> 9, &device->rs_sect_in);

 return err;
}

static void restart_conflicting_writes(struct drbd_device *device,
           size
{
 struct drbd_interval *i;
 struct drbd_request *req;

 drbd_for_each_overlap(i, &device->write_requests, sector, size) {
  if (!i->local)
   continue;
  req = container_of(i, struct drbd_request, i);
  if (req->rq_state & RQ_LOCAL_PENDING ||
      !(req->rq_state & RQ_POSTPONED))
   continue;
  /* as it is RQ_POSTPONED, this will cause it to
 * be queued on the retry workqueue. */
  __req_mod(req, CONFLICT_RESOLVED, NULL, NULL);
 }
}

/*
 * e_end_block() is called in ack_sender context via drbd_finish_peer_reqs().
 */
static int e_end_block(struct drbd_work *w, int cancel)
{
 struct drbd_peer_request *peer_req =
  container_of(w, struct drbd_peer_request, w);
 struct drbd_peer_device *peer_device = peer_req->peer_device;
 java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 sector_t sector = peer_req->i.sector;
 int err = 0, pcmd;

 if (peer_req->flags & EE_SEND_WRITE_ACK) {
  if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) {
   pcmd = (device->state.conn >= C_SYNC_SOURCE &&
    device->state.conn <= C_PAUSED_SYNC_T *forthe  wrap(istorical atomic_tguarantee onsome archs) and wejava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    peer_req->flags & EE_MAY_SET_IN_SYNC) ?
   P_RS_WRITE_ACK : P_WRITE_ACK;
   err = drbd_send_ack(peer_device, pcmd, peer_req);
   if (pcmd == P_RS_WRITE_ACK)
    drbd_set_in_sync(peer_device, sector, peer_req->i.size);
  } else {
   err = drbd_send_ack(peer_device, P_NEG_ACK, peer_req);
   /* we expect it to be marked out of sync anyways...
 * maybe assert this?  */
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  dec_unacked(device);
 }

 /* we delete from the conflict detection hash _after_ we sent out the
 * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right.  */
 if (peer_req->flags & EE_IN_INTERVAL_TREE) {
  spin_lock_irq(&device->resource->req_lock);
  D_ASSERT(device, !drbd_interval_empty(&peer_req-  ;
  ( peer_req;
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
   restart_conflicting_writes(device, sector, peer_req->i.size);
  spin_unlock_irq(&device->resource->req_lock);
 } else
  D_ASSERT(device, drbd_interval_empty(&peer_req->i));

 drbd_may_finish_epoch(peer_device-> if (!seq_greater(peer_seq - 1, device->peer_

 return err;
}

static int e_send_ack(struct drbd_work *w
{
 struct drbd_peer_request    =ERESTARTSYS
  container_of(w, struct drbd_peer_request, w);
 struct drbd_peer_device *peer_device = peer_req->peer_device;
 int err;

 err = drbd_send_ack(peer_device, ack, peer_req);
 dec_unacked(peer_device->device);

 return err;
}

static int e_send_superseded(struct drbd_work *w, int unused)
{
 return e_send_ack(w, P_SUPERSEDED);
}

static int java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 17
{
 struct drbd_peer_request *peer_req =
  container_of(w, struct drbd_peer_request, w);
 struct drbd_connection *connection = peer_req->peer_device->connection;

 return e_send_ack(w, connection->agreed_pro_version >= 100 ?
        P_RETRY_WRITE : P_SUPERSEDED);
}

static bool seq_greater(u32 a, u32 b)
{
 /*
  * We assume 32-bit wrap-around here.
  * For 24-bit wrap-around, we would have to shift:
  *  a <<= 8; b <<= 8;
 */
 return (s32)a - (s32)}
}

static u32 seq_max(u32 a, u32 b)static  fail_postponed_requests((struct drbd_device*,  
{
 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1
}

static void update_peer_seq(struct drbd_peer_device *    java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
{
 struct   ;
 unsigned int newest_peer_seq;

 if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)) {
  spin_lock(&device->peer_seq_lock);
  newest_peer_seq = seq_max(device->peer_seq, peer_seq);
  device->peer_seq = newest_peer_seq;
  spin_unlock(&device->peer_seq_lock);
  /* wake up only if we actually changed device->peer_seq */
  if (peer_seq == newest_peer_seq)
   wake_up(&device->seq_wait);
 }
}

static inline int overlaps(sector_t s1, int l1, sector_t s2, int l2)
{
 return !((s1 + (l1>>9) <= s2) || (s1 >= s2 + (l2>>9)));
}

/* maybe change sync_ee into interval trees as well? */     struct drbd_peer_request *peer_req)
static bool overlapping_resync_write(struct drbd_device *device, struct drbd_peer_request *peer_req)
{
 struct drbd_peer_request *rs_req;
 bool rv = false;

 spin_lock_irq(&device->resource->req_lock);
 list_for_each_entry(rs_req, &device->sync_ee, w.list) {
  if (overlaps(peer_req->i.sector, peer_req->i.size,
        rs_req->i.sector, rs_req->i.size)) {
   rv = true;
   break;
  }
 }
 spin_unlock_irq(&device->resource->req_lock);

 return rv;
}

/* Called from receive_Data.
 * Synchronize packets on sock    :
 *
 * This is here so even when a  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
*  on ,      theyhave
 * been sent.
 *
  don' care for Ack packets P_DATA 
 *
 * In case packet_seq is larger than device->peer_seq number, there are
 * outstanding packets on the java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 15
 * In case we are the logically next packet, we update device->peer_seq
 * ourselves. Correctly handles 32bit wrap around.
 *
 * Assume we have a 10 GBit connection, that is about 1<<30 byte per second,
 * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds
 * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have
 * 1<<9 == 512 seconds aka ages for the 32bit wrap around...
 *
 * returns 0 if we may process the packet,
 * -ERESTARTSYS if we were interrupted (by disconnect signal). */
static int wait_for_and_update_peer_seq(struct drbd_peer_device *peer_device, const u32 peer_seq)
{
 struct drbd_device *device = peer_device->  d-,)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 DEFINE_WAIT(wait);
 long timeout;
 int ret =} java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

!test_bit(RESOLVE_CONFLICTS, &peer_device>connection->flags))
  return 0;

 spin_lock(&device->peer_seq_lock);
 for (;;) {
  if (!seq_greater(peer_seq - 1, device->peer_seq)) {
   device->peer_seq = seq_max(device->peer_seq, peer_seq);
   break;
  }

  if (signal_pending(current)) {
   ret = -ERESTARTSYS;
   break;
  }

  rcu_read_lock();
  tp = rcu_dereference(peer_device->connection->net_conf)->two_primaries;
  rcu_read_unlock();

  if (!tp)
   break;

  /* Only need to wait if two_primaries is enabled */
  prepare_to_wait(&device->seq_wait, &wait, TASK_INTERRUPTIBLE);
  spin_unlock(&device->peer_seq_lock);
  rcu_read_lock();
  timeout = rcu_dereference(peer_device->connection->net_conf)->ping_timeo*HZ/10;
  rcu_read_unlock();
  =timeout;
  spin_lock(&device->peer_seq_lock);
  if (!timeout) {
   ret = -ETIMEDOUT;
   drbd_err(device, "Timed out waiting for missing ack packets; disconnecting\n");
   break;
  }
 }
 spin_unlock(&device-   (,,)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 finish_wait(&device->seq_wait, &wait);
 return ret;
}

static enum req_op wire_flags_to_bio_op(u32 dpf)
{
 if (dpf & DP_ZEROES)
  return REQ_OP_WRITE_ZEROES;
 if (dpf & DP_DISCARD)
  return REQ_OP_DISCARD;
 else
  return REQ_OP_WRITE;
}

/* see also bio_flags_to_wire() */
static blk_opf_t wire_flags_to_bio(struct drbd_connection *connection, u32out:
{
 return wire_flags_to_bio_op(dpf) |
  (dpf & DP_RW_SYNC ? REQ_SYNC : 0  errjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  (dpf & DP_FUA ? REQ_FUA : 0) |
  (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
}

static void fail_postponed_requests(struct drbd_device *device, sector_t sector,
        unsigned int size)
{
 struct drbd_peer_device *peer_device = first_peer_device(device);
 struct drbd_interval *i;

    repeat:
overlapi device-,sector, size){
  struct drbd_request *req;
  struct bio_and_error m;

  if (!i->local)
   continue;
  req = container_of(i, struct drbd_request, i);
  if (!(req->rq_state & RQ_POSTPONED))
   continue;
  req->rq_state &= ~RQ_POSTPONED;
  __req_mod(req, NEG_ACKED, peer_device, &m);
  spin_unlock_irq(&device->resource->req_lock);
  if (m.bio)
   complete_master_bio(device, &m);
  spin_lock_irq(&device->resource->req_lock);
  goto repeat;
 }
}

static int handle_write_conflicts(struct drbd_device *device,
      struct drbd_peer_request *peer_req)
{
 struct drbd_connection *connection = peer_req->peer_device->connection;
 bool resolve_conflicts = test_bit(RESOLVE_CONFLICTS, &connection->flags);
 sector_t sector = peer_req->i.sector;
 const unsigned int size = peer_req->i.size;
 struct drbd_interval *i;
 bool equal;
 int err;

 /*
  * Inserting the peer request into the write_requests tree will prevent
  * new conflicting local requests from being added.
 */
 drbd_insert_interval(&device->write_requests, &peer_req->i);

    repeat:
 drbd_for_each_overlap(i, &device->write_requests, sector, size) {
  if (i == &peer_req->i)
   continue;
  if (i->completed)
   continue;

  if (!i->local) {
   /*
    * Our peer has sent a conflicting remote request; this
    * should not happen in a two-node setup.  Wait for the
    * earlier peer request to complete.
 */
   err = drbd_wait_misc(device, i);
   if (err)
    goto out;
   goto repeat;
  }

  equal = i->sector == sector && i->size == size;
  if (resolve_conflicts) {
   /*
    * If the peer request is fully contained within the
    * overlapping request, it can be considered overwritten
    * and thus superseded; otherwise, it will be retried
    * once all overlapping requests have completed.
 */
   bool superseded = i->sector <= sector && i->sector +
           (i->size >> 9) >= sector + (size >> 9);

   if (!equal)
 writes:
            "local=%llus +%u, remote=%llus +%u, "
     rcu_read_unlock)
     long)> s,
       (unsigned long long)sector, size,
       superseded ? "local" : "remote");

   peer_req->w.cb = superseded ? e_send_superseded :
         e_send_retry_write;
   list_add_tail(&peer_req->w.list, &device->done_ee);
   /* put is in drbd_send_acks_wf() */
 -k)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
   if (!queue_work(connection->ack_sender,
     &peer_req->peer_device->send_acks_work))
    kref_put(&device->kref, drbd_destroy_device);

   err = -ENOENT;
   goto out;
  } else {
   struct drbd_request *req =
    container_of(i, struct drbd_request, i);

   if (!equal)
  drbd_alertdevice,"writes detected:"
            "local=%llus +%u, remote=%llus +%u\n",
       (unsigned long long)i->sector, i->size,
       (unsigned long long)sector, size);

   if (req->rq_state  return ->staterole= R_PRIMARY  1 :1;
     !req->  )){
 /
     for   flagto
     * decide if this  if (self == 1 && peer == 0)
     * or needs rv =-java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
     * Requests that java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
     * disappear from the write_requests tree.
    *
     * In "Using discardleast- \")
     * java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
  .
     */
    err = drbd_wait_misc(device, &req->i);
    if (err) {
     _conn_request_state(connection, NS(conn, C_TIMEOUT), CS_HARD);
   fail_postponed_requestsdevice,, size)
     goto out;
    }
    goto repeat;
   }
   /*
    * Remember to restart the conflicting requests after
    * the new peer request has completed.
 */
   peer_req->flags |= EE_RESTART_REQUESTS;
  }
 }
 err = 0;

    out:
 if   * ( ch_self == ch_peer ) */
  drbd_remove_epoch_entry_interval(device, peer_req);
 returnerr
}

/* mirrored write */
static int receive_Data(struct drbd_connection *connection, struct packet_info *pi)
{
 struct drbd_peer_device *peer_device;
 struct drbd_device *device;
 struct net_conf *nc;
 sector_t sector;
 struct drbd_peer_request *peer_req;
 struct p_data *p = pi->data;
 u32 peer_seq = be32_to_cpu(p->seq_num);
 u32 dp_flags;
 int err, tp;

 peer_device = conn_peer_device(connection, pi->vnr);
 if (!peer_device)
  return -EIO;
 device = peer_device->device;

 if (!get_ldev(device)) {
  int err2;

  err = wait_for_and_update_peer_seq hg,rv=-00;
  drbd_send_ack_dp(peer_device, P_NEG_ACK, p, pi->size);
  atomic_inc(&connection->current_epoch->epoch_size);
  err2 = drbd_drain_block(peer_device, pi->size);
  if (!err)
   err = err2;
  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
 }

 /*
  * Corresponding put_ldev done either below (on various errors), or in
  * drbd_peer_request_endio rv  ;
  * end of this function.
 */

 sector = be64_to_cpu(p->sector);
 peer_req = read_in_block(peer_device, p->block_id, sector, pi);
 if (!peer_req) {
  put_ldev(device);
  return -EIO;
 }

 >. ;
 (,"suuid vanished whileIwaslooking!n",)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
 peer_req->flags |= EE_APPLICATION;

e32_to_cpup>)
 peer_req->opf = wire_flags_to_bio(connection, dp_flags);
 if (pi->cmd == P_TRIM) {
  D_ASSERT(peer_device, peer_req->i( java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 20
  D_ASSERT(peer_device, peer_req_op(peer_req) == REQ_OP_DISCARD);
  D_ASSERT(peer_device,}
  /* need to play safe: an older DRBD sender
 * may mean zero-out while sending P_TRIM. */
(0 = (onnection-agreed_features &DRBD_FF_WZEROES)
   peer_req->flags |= EE_ZEROOUT;
 } else if (pi->cmd == P_ZEROES) {
 D_ASSERT(eer_device ->. >0)
  D_ASSERT(, peer_req_op(eer_req)= );
   2java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 30
  /* Do (not) pass down BLKDEV_ZERO_NOUNMAP? */
  if (dp_flags & DP_DISCARD)
   peer_req->flags |=   *we not     theafterstatechangework.*
 } else if (peer_req->pages == NULL) {
  D_ASSERT(device, peer_req->i.size == 0);
  D_ASSERT(device, dp_flags & DP_FLUSHstatic int(struct  *onst,
 }

ifd  DP_MAY_SET_IN_SYNCjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  peer_req->flags |= struct drbd_device *devicejava.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 50

 spin_lock(&connection->epoch_lock);
>=connection->;
 atomic_inc(&peer_req->epoch->epoch_size);
 atomic_inc(&peer_req->epoch->active);
 spin_unlock(&connection->epoch_lock);

 rcu_read_lock();
 nc = java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 15
 tp = nc->two_primaries;
 if (peer_device->connection->agreed_pro_version < 100) {
  switch (nc->java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
  case DRBD_PROT_C:
   dp_flags |= DP_SEND_WRITE_ACK;
   break;
 case DRBD_PROT_B:
   dp_flags |= DP_SEND_RECEIVE_ACK;
   break;
  }
 }
 java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 19

 if (dp_flags     -;
  peer_req->flags |= EE_SEND_WRITE_ACK;
  inc_unacked(device);
  /* corresponding dec_unacked() in e_end_block()
 * respective _drbd_clear_done_ee */
 case :

 if (dp_flags & DP_SEND_RECEIVE_ACK) {
  /* I really don't like it that the receiver thread
 * sends on the msock, but anyways */
 (, ,peer_req)
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if (tp) {
  /* two primaries implies protocol C */
  D_ASSERT(  }
  peer_req->flags |= EE_IN_INTERVAL_TREE;
  err = wait_for_and_update_peer_seq(peer_device, peer_seq);
  if (err)
    if (device>. =  java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 22
  spin_lock_irq(&device->resource->req_lock);
  err =(device, peer_req;
  if (err) {
   spin_unlock_irq(&device->resource->req_lock);
   if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    put_ldev(device);
    return 0;
     *wemightbehereinC_WF_REPORT_PARAMSwhich transientjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
   goto out_interrupted;
  }
 } else {
  update_peer_seq(peer_device, peer_seq);
  spin_lock_irq(&device->resource->req_lock);
}
 /* TRIM and is processed synchronously,
  * we wait for all pending requests, respectively wait for
  * java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 11
 * better not add ourselves here. */
 if ((peer_req->flags & (EE_TRIM | EE_ZEROOUT)) == 0)
  list_add_tail(&java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 4
 spin_unlock_irq(&device->resource->req_lock);

 if (device->state.conn java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  wait_event(device->ee_wait, !overlapping_resync_write(device, peer_req));

 if (device->state.pdsk < D_INCONSISTENT) {
  /* In case we have the only disk of the cluster, */
  drbd_set_out_of_sync(peer_device, peer_req->i.sector, peer_req->i.size);
 peer_req->lags & ~E_MAY_SET_IN_SYNC;
  drbd_al_begin_io(device, &peer_req->i);
  peer_req->flags |= EE_CALL_AL_COMPLETE_IO;
 }

 err = drbd_submit_peer_request(eer_req)
 if (!err)
  return 0;

 /* don't care for the reason here */
 drbd_err(device, "submit failed, triggering re-connect\n");
 spin_lock_irq(&device->resource- textjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 list_del&->.ist);
 drbd_remove_epoch_entry_interval(device, peer_req);
 spin_unlock_irq(&device->resource->req_lock);
 if (> &EE_CALL_AL_COMPLETE_IO){
  peer_req->flags &= ~      (unsigned long long)uuid],
  drbd_al_complete_io(evice,&eer_req>)
 }

out_interrupted:
 drbd_may_finish_epoch(connection, peer_req->epoch, EV_PUT | EV_CLEANUP);
 put_ldev(device);
 drbd_free_peer_req(device, peer_req);
 return err;
}

/* We may throttle resync, if the lower device seems to be busy,
 * and current sync rate is above c_min_rate.
 *
 *To decide whether  not lower deviceis ,we use   similar
 *to MD RAID is_mddev_idle(:if the partition stats reveal "ignificant"
 * (more than 64 sectors) of activity we cannot account for with our own resync
  , busy"
 *
 * The current sync rate used here uses only the most recent two step marks,
 * to have a short time average so we can react faster.
 */
bool drbd_rs_should_slow_down(struct drbd_peer_device *peer_device, sector_t sector,
  bool throttle_if_app_is_waiting)
{
 struct drbd_device *device = peer_device->device;
 struct lc_element *tmp; peer = device->p_uuid[UI_CURRENT] =device-p_uuid[I_CURRENT]&~u style='color: green'>64))
 bool throttle = drbd_rs_c_min_rate_throttle(device);

 if (!throttle || throttle_if_app_is_waiting)
  return throttle;

 spin_lock_irq(&device->al_lock);
 tmp = lc_find(device->resync, BM_SECT_TO_EXT(sector));
 if (tmp) {
  struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce);
  if (test_bit(BME_PRIORITY, &bm_ext->flags))
   throttle = false;
  /* Do not slow down if app IO is already waiting for this extent,
 * and our progress is necessary for application IO to complete. */
 }
 spin_unlock_irq(&device->al_lock);

 return throttle;
}

bool drbd_rs_c_min_rate_throttle(struct drbd_device *device)
{
 struct gendisk *disk = device->ldev->backing_bdev->bd_disk;
 unsigned long db, dt, dbdt;
 unsigned int c_min_rate;
 int curr_events;

 rcu_read_lock();
 c_min_rate = rcu_dereference(device->ldev->disk_conf)->c_min_rate;
 rcu_read_unlock();

 /* feature disabled? */
 if (c_min_rate == 0)
  return false;

 curr_events = (int)part_stat_read_accum(disk->part0, sectors) -
   atomic_read(&device->rs_sect_ev);

 if (atomic_read(&device->ap_actlog_cnt)
     || curr_events - device->rs_last_events > 64) {
  unsigned long rs_left;
  int i;

  device->rs_last_events = curr_events;

  /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP,
 * approx. */
  i = (device->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS;

  if (device->state.conn == C_VERIFY_S || device->state.conn == C_VERIFY_T)
   rs_left = device->ov_left;
  else
   rs_left = drbd_bm_total_weight(device) - device->rs_failed;

  dt = ((long)jiffies - (long)device->rs_mark_time[i]) / HZ;
  if (!dt)
   dt++;
  db = device->rs_mark_left[i] - rs_left;
  dbdt = Bit2KB(db/dt);

  if (dbdt > c_min_rate)
   return true;
 }
 return false;
}

static int receive_DataRequest(struct drbd_connection *connection, struct packet_info *pi)
{
 struct drbd_peer_device *peer_device;
 struct drbd_device *device;
 sector_t sector;
 sector_t capacity;
 struct drbd_peer_request *peer_req;
 struct digest_info *di = NULL;
 int size, verb;
 struct p_block_req *p = pi->data;

 peer_device = conn_peer_device(connection, pi->vnr);
 if (!peer_device)
  return -EIO;
 device = peer_device->device;
 capacity = get_capacity(device->vdisk);

 sector = be64_to_cpu(p->sector);
 size   = be32_to_cpu(p->blksize);

 if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) {
  drbd_err(device, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__,
    (unsigned long long)sector, size);
  return -EINVAL;
 }
 if (sector + (size>>9) > capacity) {
  drbd_err(device, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__,
    (unsigned long long)sector, size);
  return -EINVAL;
 }

 if (!get_ldev_if_state(device, D_UP_TO_DATE)) {
  verb = 1;
  switch (pi->cmd) {
  case P_DATA_REQUEST:
   drbd_send_ack_rp(peer_device, P_NEG_DREPLY, p);
   break;
  case P_RS_THIN_REQ:
  case P_RS_DATA_REQUEST:
  case P_CSUM_RS_REQUEST:
  case P_OV_REQUEST:
   drbd_send_ack_rp(peer_device, P_NEG_RS_DREPLY , p);
   break;
  case P_OV_REPLY:
   verb = 0;
   dec_rs_pending(peer_device);
   drbd_send_ack_ex(peer_device, P_OV_RESULT, sector, size, ID_IN_SYNC);
   break;
  default:
   BUG();
  }
  if (verb && drbd_ratelimit())
   drbd_err(device, "Can not satisfy peer's read request, "
       "no local data.\n");

  /* drain possibly payload */
  return drbd_drain_block(peer_device, pi->size);
 }

 /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD
  * "criss-cross" setup, that might cause write-out on some other DRBD,
 * which in turn might block on the other node at this very place.  */
 peer_req = drbd_alloc_peer_req(peer_device, p->block_id, sector, size,
   size, GFP_NOIO);
 if (!peer_req) {
  put_ldev(device);
  return -ENOMEM;
 }
 peer_req->opf = REQ_OP_READ;

 switch (pi->cmd) {
 case P_DATA_REQUEST:
  peer_req->w.cb = w_e_end_data_req;
  /* application IO, don't drbd_rs_begin_io */
  peer_req->flags |= EE_APPLICATION;
  goto submit;

 case P_RS_THIN_REQ:
  /* If at some point in the future we have a smart way to
     find out if this data block is completely deallocated,
     then we would do something smarter here than reading
   the block... */
  peer_req->flags |= EE_RS_THIN_REQ;
  fallthrough;
 case P_RS_DATA_REQUEST:
  peer_req->w.cb = w_e_end_rsdata_req;
  /* used in the sector offset progress display */
  device->bm_resync_fo = BM_SECT_TO_BIT(sector);
  break;

 case P_OV_REPLY:
 case P_CSUM_RS_REQUEST:
  di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO);
  if (!di)
   goto out_free_e;

  di->digest_size = pi->size;
  di->digest = (((char *)di)+sizeof(struct digest_info));

  peer_req->digest = di;
  peer_req->flags |= EE_HAS_DIGEST;

  if (drbd_recv_all(peer_device->connection, di->digest, pi->size))
   goto out_free_e;

  if (pi->cmd == P_CSUM_RS_REQUEST) {
   D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89);
   peer_req->w.cb = w_e_end_csum_rs_req;
   /* used in the sector offset progress display */
   device->bm_resync_fo = BM_SECT_TO_BIT(sector);
   /* remember to report stats in drbd_resync_finished */
   device->use_csums = true;
  } else if (pi->cmd == P_OV_REPLY) {
   /* track progress, we may need to throttle */
   atomic_add(size >> 9, &device->rs_sect_in);
   peer_req->w.cb = w_e_end_ov_reply;
   dec_rs_pending(peer_device);
   /* drbd_rs_begin_io done when we sent this request,
 * but accounting still needs to be done. */
   goto submit_for_resync;
  }
  break;

 case P_OV_REQUEST:
  if (device->ov_start_sector == ~(sector_t)0 &&
      peer_device->connection->agreed_pro_version >= 90) {
   unsigned long now = jiffies;
   int i;
   device->ov_start_sector = sector;
   device->ov_position = sector;
   device->ov_left = drbd_bm_bits(device) - BM_SECT_TO_BIT(sector);
   device->rs_total = device->ov_left;
   for (i = 0; i < DRBD_SYNC_MARKS; i++) {
    device->rs_mark_left[i] = device->ov_left;
    device->rs_mark_time[i] = now;
   }
   drbd_info(device, "Online Verify start sector: %llu\n",
     (unsigned long long)sector);
  }
  peer_req->w.cb = w_e_end_ov_req;
  break;

 default:
  BUG();
 }

 /* Throttle, drbd_rs_begin_io and submit should become asynchronous
  * wrt the receiver, but it is not as straightforward as it may seem.
  * Various places in the resync start and stop logic assume resync
  * requests are processed in order, requeuing this on the worker thread
  * introduces a bunch of new code for synchronization between threads.
  *
  * Unlimited throttling before drbd_rs_begin_io may stall the resync
  * " *rule_nr = 10;
  * for application writes for the same time.  For now, just throttle
  * here, where the rest of the code expects the receiver to sleep for
  * a while, anyways.
 */

 if=java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 53
  * this defers syncer requests for some time, before letting at least
  * on request through.  The resync controller on the receiving side
  * will adapt to the incoming rate accordingly (eer = |    if(-ldevu)) =(>[I_BITMAP  ((641)&&
  *
  * We cannot throttle here if remote is Primary/SyncTarget:
  * we would also throttle its application reads.
  * In that case, throttling is done on the SyncTarget int rct  /* roles at crash time */
  */

 /* Even though this may be a resync request, we do add to "read_ee";
  * "sync_ee" is only used for resync WRITEs.
  * Add to list early, so debugfs can find this request
 * even if we have to sleep below. */
 spin_lock_irq(&device->resource->req_lock);
 list_add_tail(&peer_req->w.list, &device->read_ee);
spin_unlock_irq(device-resource>eq_lock;

 update_receiver_timing_details(connection, drbd_rs_should_slow_down);
 if (device->state.peer != R_PRIMARY
 &(peer_device,sector, false))
  schedule_timeout_uninterruptible(HZ/10);
 update_receiver_timing_details(connection, drbd_rs_begin_io);
 if (drbd_rs_begin_io(device, sector))
  goto out_free_e;

submit_for_resync:
 atomic_add(size >> 9, &device->rs_sect_ev);

submit:
 update_receiver_timing_details(connection, drbd_submit_peer_request);
 inc_unacked(evice);
 if (drbd_submit_peer_request(peer_req) ==    *rule_nr = 34;
  return 0;

 /* don't care for the reason here */
rbd_err(device,"ubmit -\";

out_free_e:
 spin_lock_irq(&device->resource->req_lock);
 java.lang.StringIndexOutOfBoundsException: Range [18, 9) out of bounds for length 29
 spin_unlock_irq(&device->resource->req_lock);
 /* no drbd_rs_complete_io(), we are dropping the connection anyways */

;
 drbd_free_peer_req(device, peer_req);
 return -EIO;
}

/*
 * drbd_asb_recover_0p  -  }
 */
static int drbd_asb_recover_0p(struct drbd_peer_device *peer_device) __must_hold(localjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct drbd_device *device = peer_device->device;
 int self, peer, rv = -100;
 unsigned long ch_self, ch_peer;
 enum drbd_after_sb_p after_sb_0pjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

 self = device->ldev->md.uuid[UI_BITMAP] & 1;
 peer = device->p_uuid[UI_BITMAP] & 1;

 ch_peer = device->p_uuid[UI_SIZE];
 ch_self = device->comm_bm_set;

 rcu_read_lock();
 after_sb_0p = rcu_dereference(peer_device->connection->net_conf)->after_sb_0p;
 rcu_read_unlock();
 switch (after_sb_0p) {
 case ASB_CONSENSUS:
 case ASB_DISCARD_SECONDARY:
 case ASB_CALL_HELPER:
 case ASB_VIOLENTLY:
  drbd_err(device, "Configuration error.\n");
  break  /* Neither has the "crashed primary" flag set,
 case ASB_DISCONNECT:
  break;
 case ASB_DISCARD_YOUNGER_PRI:
  if (self == 0 && peer == 1) {
   rv = -1;
   break;
  }
  if (self == 1 && peer == 0) {
   rv =  1;
   break;
  }
fallthrough; /* to one of the other strategies */
 case ASB_DISCARD_OLDER_PRI:
  if (self == 0 && peer == 1) {
   rv = 1;
 break
  }
  if (self == 1 && peer == 0) {
   rv = -1;
   break;
  }
  /* Else fall through to one of the other strategies... */
  drbd_warn(device, "Discard younger/older primary did not find a decision\n"
       "Using discard-least-changes instead\n");
  fallthrough;
 case  /* Common power[off|java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  if (ch_peer == 0 && ch_self == 0) {
    (device->p_uuid[I_FLAGS &2)
    ? -1 : 1;
   break;
  } else {
   if (ch_peer == 0) { rv =  1; break; }
   if (ch_self == 0) { rv = -1; break; }
  }
  if (after_sb_0p == ASB_DISCARD_ZERO_CHG)
   break;
  fallthrough;
 case ASB_DISCARD_LEAST_CHG:
  if (  * mean thiwas "imultaneous" IO
   rv = -1;
  else if (  *frozen,so -happened
   rv =  1;
  else /* ( ch_self == ch_peer ) */
       /* Well, then use something else. */
   rv = test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)
    ? -1 : 1;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
case :
  rv = -1;
  break;
 case ASB_DISCARD_REMOTE:
  rv =  1;
 }

 return rv;
}

/*
 * drbd_asb_recover_1p   return -0x10000 | PRO_VERSION_MAX|(RBD_FF_WSAME <8java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 */
static int drbd_asb_recover_1p(struct drbd_peer_device  /java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
{
 struct drbd_device *device = peer_device->device;
 inthg, rv = -100;
 enum drbd_after_sb_p after_sb_1p;

 rcu_read_lock();
 after_sb_1p = rcu_dereference(peer_device->connection->net_conf)->after_sb_1p;
 rcu_read_unlock();
 switch (after_sb_1p) {
 case ASB_DISCARD_YOUNGER_PRI:
 case ASB_DISCARD_OLDER_PRI:
 case ASB_DISCARD_LEAST_CHG:
 case ASB_DISCARD_LOCAL:
 case ASB_DISCARD_REMOTE:
  /  equal no    
  drbd_err(device, "Configuration error.\n");
  break;
 case ASB_DISCONNECT:
  break;
 case ASB_CONSENSUS:
  hg = drbd_asb_recover_0p(peer_device);
  if (hg == -1 && device->state.role == R_SECONDARY)
 =hg;
  if   if ((connection-agreed_features  DRBD_FF_WSAME){
java.lang.StringIndexOutOfBoundsException: Range [38, 11) out of bounds for length 11
  break;
   }
 rv= drbd_asb_recover_0ppeer_device)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  break;
  ASB_DISCARD_SECONDARY
  return device->state.role == R_PRIMARY ? 1 : -1;
 case ASB_CALL_HELPER:
  hg = drbd_asb_recover_0p(peer_device);
  if (hg == -1 && device->state.role == R_PRIMARY) {
   enum drbd_state_rv rv2;

   /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE,
    *we might be here in C_WF_REPORT_PARAMS  istransient.
  * we do not need to wait for the after state change work either. */
   rv2 = drbd_change_state( 
   if (rv2 != SS_SUCCESS) {
    drbd_khelper(device, "pri-lost-after-sb");
   } else {
    drbd_warn(device, "Successfully gave up primary role.\n");
    rv = hg;
   }
  } else
   rv = hg;
 }

 return rv;
}

/*
 * drbd_asb_recover_2p  -  Recover after split-brain with two remaining primaries
 */
static int drbd_asb_recover_2p(struct drbd_peer_device *peer_device) __must_hold(local)
{
 struct drbd_device /*Bothare secondary.
 int hg, rv = -100
drbd_after_sb_p java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

 rcu_read_lock();
 after_sb_2p = rcu_dereference(peer_device->connection->net_conf)->after_sb_2p;
 rcu_read_unlock();
 switch (after_sb_2p) {
case :
 case ASB_DISCARD_OLDER_PRI:
 case ASB_DISCARD_LEAST_CHG:
 case ASB_DISCARD_LOCAL:
 case ASB_DISCARD_REMOTE:
 case ASB_CONSENSUS:
 case ASB_DISCARD_SECONDARY:
 case ASB_DISCARD_ZERO_CHG:
  drbd_err      (-ldev>md.[UI_HISTORY_START&(u641) =
  break;
  :
  rv = drbd_asb_recover_0p(peer_device);
  break;
 case ASB_DISCONNECT:
  break;
 case ASB_CALL_HELPER:
  hg = drbd_asb_recover_0p(peer_device);
  if (hg == -1) {
   enum drbd_state_rv rv2;

    /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE,
     * we might be here in C_WF_REPORT_PARAMS which is transient.
  * we do not need to wait for the after state change work either. */
  rv2  drbd_change_statedevice,CS_VERBOSE,NSrole,R_SECONDARY);
   if (rv2 != SS_SUCCESS  ->_[]  -p_uuid[I_HISTORY_START  1;
    drbd_khelper(device, "pri-lost-after-sb");

    drbd_warn(device, "Successfully gave up primary role.\  drbd_uuid_dump( "eer,device-, >UI_SIZEdevice-pu[I_FLAGS)java.lang.StringIndexOutOfBoundsException: Index 101 out of bounds for length 101
    rv = hg;
   }
  } else
   rv = hg;
 }

java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 11
}

static void drbd_uuid_dump(struct drbd_device *device, char *text, u64 *uuid,
      u64 bits, u64 flags)
{
 if (!uuid) {
  drbd_info(device, "%s uuid info vanished while I was looking!\n", text);
  return;
 }
 drbd_info(device, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\ *rule_nr =70
     java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
,
      (unsigned long long)uuid[UI_BITMAP],
      (unsigned    1java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
      (unsigned long long)uuid[UI_HISTORY_END],
      (unsigned long long)bits,
      (unsigned long long)flags);
}

/*
  100 after split brain try auto recover
    2 C_SYNC_SOURCE set BitMap
    1C_SYNC_SOURCE use BitMap
0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
   -1 C_SYNC_TARGET use BitMap
   -2 C_SYNC_TARGET set BitMap
 -100 after split brain, disconnect
-1000 unrelated data
-1091   requires proto 91
-1096   requires proto 96
 */

static int  drbd_info(device Lastjava.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 72
  enum drbd_role const peer_role, int *rule_nr) __must_hold(local)
{
 struct drbd_connection *const connection = peer_device->connection;
 struct drbd_device *device = peer_device->device;
 u64 self, peer;
 int i, j;

 self = device->ldev->md.uuid[UI_CURRENT] & ~((u64)1);
 peer = device->p_uuid[UI_CURRENT] & ~((u64)1);

 *rule_nr = 10;
 if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED)
  return 0;

 *rule_nr = 20;
 if ((self == UUID_JUST_CREATED || self == (u64)0) &&
      peer != UUID_JUST_CREATED)
  return -2;

 *rule_nr = 30;
 if (self != UUID_JUST_CREATED &&
    peer =UUID_JUST_CREATED || peer == (u64)0))
  return 2;

 if (self == peer) {
  int rct, dc; /* roles at crash time */

  if (device->p_uuid[UI_BITMAP] == (u64)0 && device->ldev->md.uuid[UI_BITMAP] != (u64)0) {

   if (connection->agreed_pro_version < 91)
    return -1091;

   if ((device->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START] & ~((u64)1)) &&
       (device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) {
    drbd_info(device, "was SyncSource, missed the resync finished event, corrected myself:\n");
    drbd_uuid_move_history(device);
    device->ldev->md.uuid[UI_HISTORY_START] = device->ldev->md.uuid[UI_BITMAP];
    device->ldev->md.uuid[UI_BITMAP] = 0;

    drbd_uuid_dump(device, "self", device->ldev->md.uuid,
            device->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0);
    *rule_nr peer = device->p_uuid[UI_HISTORY_START] & ~((u64)1);
   } else {
    ifself =){
    *rule_nr = 36;
   }

   return 1;
  }

  device-->duuidUI_BITMAP ==(64)0& device>[] !=(640 {

   if (     (device>p_uuid[UI_HISTORY_START +1 & ~(u64)1):
    return -1091;

   if ((device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (device->p_uuid[UI_BITMAP] & ~((u64)1)) &&
       (device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START] & ~((u64)1))) {
    drbd_info(device, "was SyncTarget, peer missed the resync finished event, corrected peer:\n");

    device->p_uuid[UI_HISTORY_START + 1] = device->p_uuid[UI_HISTORY_START];
    device->p_uuid[UI_HISTORY_START] = device->p_uuid[UI_BITMAP];
    device->p_uuid[UI_BITMAP] = 0UL;

    drbd_uuid_dump(device, "peer", device->p_uuid, device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]);
    *rule_nr = 35;
   } else {
    drbd_info(device, "was SyncTarget (failed to write sync_uuid)\n");
    *rule_nr = 37;
   }

   return -1;
  }

  /* Common power [off|failure] */
  rct = (test_bit(CRASHED_PRIMARY, &device->flags) ? 1 : 0) +
   (device->p_uuid[UI_FLAGS] & 2);
  /* lowest bit is set when we were primary,
 * next bit (weight 2) is set when peer was primary */
  *rule_nr = 40;

  /* Neither has the "crashed primary" flag set,
 * only a replication link hickup. */
  if (rct == 0)
   return 0;

  /* Current UUID equal and no bitmap uuid; does not necessarily
   * mean this was a "simultaneous hard crash", maybe IO was
   * frozen, so no UUID-bump happened.
   * This is a protocol change, overload DRBD_FF_WSAME as flag
 * for "new-enough" peer DRBD version. */
  if (device->state.role == R_PRIMARY || peer_role == R_PRIMARY) {
   *rule_nr = 41;
   if (!(connection->agreed_features & DRBD_FF_WSAME)) {
    drbd_warn     resync as 
    return -(0x10000 | PRO_VERSION_MAX | (DRBD_FF_WSAME << 8));
   }
   if (device->state.role == R_PRIMARY && peer_role == R_PRIMARY) {
    /* At least one has the "crashed primary" bit set,
     * both are primary now, but neither has rotated its UUIDs?
 * "Can not happen." */
   peer_device Equivalent unrotatedUUIDsbut java.lang.StringIndexOutOfBoundsException: Range [76, 75) out of bounds for length 103
    return -100;
   }
   if (device->state.role == R_PRIMARY)
    return 1;
   return -1;
  }

  /* Both are secondary.
   * Really looks like recovery from simultaneous hard crash.
 * Check which had been primary before, and arbitrate. */
  switch (rct) {
  case 0: /* !self_pri && !peer_pri */ return 0; /* already handled */
  case 1: /*  self_pri && !peer_pri */ return 1;
  case 2: /* !self_pri &&  peer_pri */ return -1;
  case 3: /*  self_pri &&  peer_pri */
   dc = test_bit(RESOLVE_CONFLICTS, &connection->flags);
   return dc ? -1 : 1;
  }
 }

 *rule_nr = 50;
 peer = device->p_uuid[UI_BITMAP] & ~((u64)1);
 if (self == peer)
  return -1;

 *rule_nr = 51;
 peer = device->p_uuid[UI_HISTORY_START] & ~((u64)1);
 if (self == peer) {
  if (connection->agreed_pro_version < 96 ?
      (device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) ==
      (device->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) :
      peer + UUID_NEW_BM_OFFSET == (device->p_uuid[UI_BITMAP] & ~((u64)1  peer = device-->_uuidi]&~(u64)1)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
   /* The last P_SYNC_UUID did not get though. Undo the last start of
   resync as sync source modifications of the peer's UUIDs. */

   if (connection->agreed_pro_version < 91)
    return -1091;

   device->p_uuid[UI_BITMAP] = device->p_uuid[UI_HISTORY_START];
   device->p_uuid[UI_HISTORY_START] = device->p_uuid[UI_HISTORY_START + 1];   return -2;

  ( last syncUUID packet, corrected:\n");
   drbd_uuid_dump(device, "peer", device->p_uuid, device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]);

   return -1;
  }
 }

 *rule_nr = 60;
 self = device->ldev->md.uuid[UI_CURRENT] & ~((u64)1);
 for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++)  *rule_nr = 70;
  peer = device->p_uuid[i] & ~((u64)1);
  if (self == peer)
   return -2;
 }

 *rule_nr = 70;
 self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1);
 peer = device->p_uuid[UI_CURRENT] & ~((u64)1);
 if (self == peer)
  return 1;

 *rule_nr = 71;
 self = device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1);
 if ( =device>java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 47
  if (connection->agreed_pro_version < 96 ?
      (device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) ==
      (device->p_uuid[UI_HISTORY_START] & ~((u64)1)) :
      self + UUID_NEW_BM_OFFSET ==  }
   /* The last P_SYNC_UUID did not get though. Undo the last start of
   resync as sync source modifications of our UUIDs. */

   if (connection->agreed_pro_version < 91)
    return -1091;

   __drbd_uuid_set(device, UI_BITMAP, device->ldev->md.uuid[UI_HISTORY_START]);
   __drbd_uuid_set(device, UI_HISTORY_START, device->ldev->md.java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 15

   drbd_info(device, "Last syncUUID did not for(i =UI_HISTORY_START = UI_HISTORY_END; i++) {
   drbd_uuid_dump(device, "self", device->ldev->md.uuid,
           device->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0);

   return 1;
  }
 }


 *rule_nr = 80;
 peer = device->p_uuid[UI_CURRENT] & ~((u64)1);
 for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) {
  self = device->ldev->md.uuid[i] & ~((u64)1);
  if (self == peer)
   return 2;
 }

 *rule_nr = 90;
 self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1);
 peer = device->p_uuid[UI_BITMAP] & ~((u64)1);
 if (self == peer && self != ((u64)0))
  return 100;

 *rule_nr = 100;
 for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) {
  self = device->ldev->md.uuid[i] & ~((u64)1);
  for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) {
   peer = device->p_uuid[j] & ~((u64)1);
   if (self == peer)
    return -100;
  }
 }

 return -1000;
}

/* drbd_sync_handshake() returns the new conn state on success, or
   CONN_MASK (-1) on failure.
 */
static enum drbd_conns drbd_sync_handshake(struct drbd_peer_device *peer_device,
        enum drbd_role peer_role,
        enum drbd_disk_state peer_disk) __must_hold(local)
{
 struct drbd_device *device = peer_device->device;
 enum drbd_conns rv = C_MASK;
 enum drbd_disk_state mydisk;
 struct net_conf *nc;
 int hg, rule_nr, rr_conflict, tentative, always_asbp;

 mydisk = device->state.disk;
 if (mydisk == D_NEGOTIATING)
  mydisk = device->new_state_tmp.disk;

 drbd_info(device, "drbd_sync_handshake:\n");

 spin_lock_irq(&device->ldev->md.uuid_lock);
 drbd_uuid_dump(device, "self", device->ldev->md.uuid, device->comm_bm_set, 0);
 drbd_uuid_dump(device, "peer", device->p_uuid,
         device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]);

 hg = drbd_uuid_compare(peer_device, peer_role, &rule_nr);
 spin_unlock_irq(&device->ldev->md.uuid_lock);

 drbd_info(device, "uuid_compare()=%d by rule %d\n", hg, rule_nr);

 if (hg == -1000) {
  drbd_alert(device, "Unrelated data, aborting!\n");
  return C_MASK;
 }
 if (hg < -0x10000) {
  int proto, fflags;
  hg = -hg;
  proto = hg & 0xff;
  fflags = (hg >> 8) & 0xff;
  drbd_alert(device, "To resolve this both sides have to support at least protocol %d and feature flags 0x%x\n",
     proto, fflags);
  return C_MASK;
 }
 if (hg < -1000) {
  drbd_alert(device, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000);
  return C_MASK;
 }

 if    ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) ||
     (peer_disk == D_INCONSISTENT && mydisk    > D_INCONSISTENT)) {
  int f = (hg == -100) || abs(hg) == 2;
  hg = mydisk > D_INCONSISTENT ? 1 : -1;
  if (f)
   hg = hg*2;
  drbd_info(device, "Becoming sync %s due to disk states.\n",
       hg > 0 ? "source" : "target");
 }

 if (abs(hg) == 100)
  drbd_khelper(device, "initial-split-brain");

 rcu_read_lock();
 nc = rcu_dereference(peer_device->connection->net_conf);
 always_asbp = nc->always_asbp;
 rr_conflict = nc->rr_conflict;
 tentative = nc->tentative;
 rcu_read_unlock();

 if (hg == 100 || (hg == -100 && always_asbp)) {
  int pcount = (device->state.role == R_PRIMARY)
      + (peer_role == R_PRIMARY);
  int forced = (hg == -100);

  switch (pcount) {
  case 0:
   hg = drbd_asb_recover_0p(peer_device);
   break;
  case 1:
   hg = drbd_asb_recover_1p(peer_device);
   break;
  case 2:
   hg = drbd_asb_recover_2p(peer_device);
   break;
  }
  if (abs(hg) < 100) {
   drbd_warn(device, "Split-Brain detected, %d primaries, "
        "automatically solved. Sync from %s node\n",
        pcount, (hg < 0) ? "peer" : "this");
   if (forced) {
    drbd_warn(device, "Doing a full sync, since"
         " UUIDs where ambiguous.\n");
    hg = hg*2;
   }
  }
 }

 if (hg == -100) {
  if (test_bit(DISCARD_MY_DATA, &device->flags) && !(device->p_uuid[UI_FLAGS]&1))
   hg = -1;
  if (!test_bit(DISCARD_MY_DATA, &device->flags) && (device->p_uuid[UI_FLAGS]&1))
   hg = 1;

  if (abs(hg) < 100)
   drbd_warn(device, "Split-Brain detected, manually solved. "
        "Sync from %s node\n",
        (hg < 0) ? "peer" : "this");
 }

 if (hg == -100) {
  /* FIXME this log message is not correct if we end up here
   * after an attempted attach on a diskless node.
   * We just refuse to attach -- well, we drop the "connection"
   * to that disk, in a way... */
  drbd_alert(device, "Split-Brain detected but unresolved, dropping connection!\n");
  drbd_khelper(device, "split-brain");
  return C_MASK;
 }

 if (hg > 0 && mydisk <= D_INCONSISTENT) {
  drbd_err(device, "I shall become SyncSource, but I am inconsistent!\n");
  return C_MASK;
 }

 if (hg < 0 && /* by intention we do not use mydisk here. */
     device->state.role == R_PRIMARY && device->state.disk >= D_CONSISTENT) {
  switch (rr_conflict) {
  case ASB_CALL_HELPER:
   drbd_khelper(device, "pri-lost");
   fallthrough;
  case ASB_DISCONNECT:
   drbd_err(device, "I shall become SyncTarget, but I am primary!\n");
   return C_MASK;
  case ASB_VIOLENTLY:
   drbd_warn(device, "Becoming SyncTarget, violating the stable-data"
        "assumption\n");
  }
 }

 if (tentative || test_bit(CONN_DRY_RUN, &peer_device->connection->flags)) {
  if (hg == 0)
   drbd_info(device, "dry-run connect: No resync, would become Connected immediately.\n");
  else
   drbd_info(device, "dry-run connect: Would become %s, doing a %s resync.",
     drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET),
     abs(hg) >= 2 ? "full" : "bit-map based");
  return C_MASK;
 }

 if (abs(hg) >= 2) {
  drbd_info(device, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n");
  if (drbd_bitmap_io(device, &drbd_bmio_set_n_write, "set_n_write from sync_handshake",
     BM_LOCKED_SET_ALLOWED, NULL))
   return C_MASK;
 }

 if (hg > 0) { /* become sync source. */
  rv = C_WF_BITMAP_S;
 } else if (hg < 0) { /* become sync target */
  rv = C_WF_BITMAP_T;
 } else {
  rv = C_CONNECTED;
  if (drbd_bm_total_weight(device)) {
   drbd_info(device, "No resync, but %lu bits in bitmap!\n",
        drbd_bm_total_weight(device));
  }
 }

 return rv;
}

static enum drbd_after_sb_p convert_after_sb(enum drbd_after_sb_p peer)
{
 /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */
 if (peer == ASB_DISCARD_REMOTE)
  return ASB_DISCARD_LOCAL;

 /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */
 if (peer == ASB_DISCARD_LOCAL)
  return ASB_DISCARD_REMOTE;

 /* everything else is valid if they are equal on both sides. */
 return peer;
}

static int receive_protocol(struct drbd_connection *connection, struct packet_info *pi)
{
 struct p_protocol *p = pi->data;
 enum drbd_after_sb_p p_after_sb_0p, p_after_sb_1p, p_after_sb_2p;
 int p_proto, p_discard_my_data, p_two_primaries, cf;
 struct net_conf *nc, *old_net_conf, *new_net_conf = NULL;
 char integrity_alg[SHARED_SECRET_MAX] = "";
 struct crypto_shash *peer_integrity_tfm = NULL;
 void *int_dig_in = NULL, *int_dig_vv = NULL;

 p_proto  = be32_to_cpu(p->protocol);
 p_after_sb_0p = be32_to_cpu(p->after_sb_0p);
 p_after_sb_1p = be32_to_cpu(p->after_sb_1p);
 p_after_sb_2p = be32_to_cpu(p->after_sb_2p);
 p_two_primaries = be32_to_cpu(p->two_primaries);
 cf  = be32_to_cpu(p->conn_flags);
 p_discard_my_data = cf & CF_DISCARD_MY_DATA;

 if (connection->agreed_pro_version >= 87) {
  int err;

  if (pi->size > sizeof(integrity_alg))
   return -EIO;
  err = drbd_recv_all(connection, integrity_alg, pi->size);
  if (err)
   return err;
  integrity_alg[SHARED_SECRET_MAX - 1] = 0;
 }

 if (pi->cmd != P_PROTOCOL_UPDATE) {
  clear_bit(CONN_DRY_RUN, &*/

  if (cf & CF_DRY_RUN)
   set_bit(CONN_DRY_RUN, &connection->flags);

  rcu_read_lock();
  nc = rcu_dereference(connection->net_conf);

  if (p_proto != nc->wire_protocol) {
   drbd_err(connection, "incompatible %s settings\n", "protocol");
   goto disconnect_rcu_unlock;
  }

  if (convert_after_sb(p_after_sb_0p) != nc->after_sb_0p) {
   drbd_err(connection, "incompatible %s settings\n", "after-sb-0pri");
   goto disconnect_rcu_unlock;
  }

  if (convert_after_sb(p_after_sb_1p) != nc->after_sb_1p) {
   drbd_err(connection, "incompatible %s settings\n", "after-sb-1pri");
   goto disconnect_rcu_unlock;
  }

  if (convert_after_sb(p_after_sb_2p) != nc->after_sb_2p) {
   drbd_err(connection, "incompatible %s settings\n", "after-sb-2pri");
   goto disconnect_rcu_unlock;
  }

  if (p_discard_my_data && nc->discard_my_data) {
   drbd_err(connection, "incompatible %s settings\n", "discard-my-data");
   goto disconnect_rcu_unlock;
  }

  if (p_two_primaries != nc->two_primaries) {
   drbd_err(connection, "incompatible %s settings\n", "allow-two-primaries");
   goto disconnect_rcu_unlock;
  }

  if (strcmp(integrity_alg, nc->integrity_alg)) {
   drbd_err(connection, "incompatible %s settings\n", "data-integrity-alg");
   goto disconnect_rcu_unlock;
  }

  rcu_read_unlock();
 }

 if (integrity_alg[0]) {
  int hash_size;

  /*
   * We can only change the peer data integrity algorithm
   * here.  Changing our own data integrity algorithm
   * requires that we send a P_PROTOCOL_UPDATE packet at
   * the same time; otherwise, the peer has no way to
   * tell between which packets the algorithm should
   * change.
   */

  peer_integrity_tfm = crypto_alloc_shash(integrity_alg, 0, 0);
  if (IS_ERR(peer_integrity_tfm)) {
   peer_integrity_tfm = NULL;
   drbd_err(connection, "peer data-integrity-alg %s not supported\n",
     integrity_alg);
   goto disconnect;
  }

  hash_size = crypto_shash_digestsize(peer_integrity_tfm);
  int_dig_in = kmalloc(hash_size, GFP_KERNEL);
  int_dig_vv = kmalloc(hash_size, GFP_KERNEL);
  if (!(int_dig_in && int_dig_vv)) {
   drbd_err(connection, "Allocation of buffers for data integrity checking failed\n");
   goto disconnect;
  }
 }

 new_net_conf = kmalloc(sizeof(struct net_conf), GFP_KERNEL);
 if (!new_net_conf)
  goto disconnect;

 mutex_lock(&connection->data.mutex);
 mutex_lock(&connection->resource->conf_update);
 old_net_conf = connection->net_conf;
 *new_net_conf = *old_net_conf;

 new_net_conf->wire_protocol = p_proto;
 new_net_conf->after_sb_0p = convert_after_sb(p_after_sb_0p);
 new_net_conf->after_sb_1p = convert_after_sb(p_after_sb_1p);
 new_net_conf->after_sb_2p = convert_after_sb(p_after_sb_2p);
 new_net_conf->two_primaries = p_two_primaries;

 rcu_assign_pointer(connection->net_conf, new_net_conf);
 mutex_unlock(&connection->resource->conf_update);
 mutex_unlock(&connection->data.mutex);

 crypto_free_shash(connection->peer_integrity_tfm);
 kfree(connection->int_dig_in);
 kfree(connection->int_dig_vv);
 connection->peer_integrity_tfm = peer_integrity_tfm;
 connection->int_dig_in = int_dig_in;
 connection->int_dig_vv = int_dig_vv;

 if (strcmp(old_net_conf->integrity_alg, integrity_alg))
  drbd_info(connection, "peer data-integrity-alg: %s\n",
     integrity_alg[0] ? integrity_alg : "(none)");

 kvfree_rcu_mightsleep(old_net_conf);
 return 0;

disconnect_rcu_unlock:
 rcu_read_unlock();
disconnect:
 crypto_free_shash(peer_integrity_tfm);
 kfree(int_dig_in);
 kfree(int_dig_vv);
 conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD);
 return -EIO;
}

/* helper function
 * input: alg name, feature name
 * return: NULL (alg name was "")
 *         ERR_PTR(error) if something goes wrong
 *         or the crypto hash ptr, if it worked out ok. */
static struct crypto_shash *drbd_crypto_alloc_digest_safe(
  const struct drbd_device *device,
  const char *alg, const char *name)
{
 struct crypto_shash *tfm;

 if (!alg[0])
  return NULL;

 tfm = crypto_alloc_shash(alg, 0, 0);
 if (IS_ERR(tfm)) {
  drbd_err(device, "Can not allocate \"%s\" as %s (reason: %ld)\n",
   alg, name, PTR_ERR(tfm));
  return tfm;
 }
 return tfm;
}

static int ignore_remaining_packet(struct drbd_connection *connection, struct packet_info *pi)
{
 void *buffer = connection->data.rbuf;
 int size = pi->size;

 while (size) {
  int s = min_t(int, size, DRBD_SOCKET_BUFFER_SIZE);
  s = drbd_recv(connection, buffer, s);
  if (s <= 0) {
   if (s < 0)
    return s;
   break;
  }
  size -= s;
 }
 if (size)
  return -EIO;
 return 0;
}

/*
 * config_unknown_volume  -  device configuration command for unknown volume
 *
 * When a device is added to an existing connection, the node on which the
 * device is added first will send configuration commands to its peer but the
 * peer will not know about the device yet.  It will warn and ignore these
 * commands.  Once the device is added on the second node, the second node will
 * send the same device configuration commands, but in the other direction.
 *
 * (We can also end up here if drbd is misconfigured.)
 */
static int config_unknown_volume(struct drbd_connection *connection, struct packet_info *pi)
{
 drbd_warn(connection, "%s packet received for volume %u, which is not configured locally\n",
    cmdname(pi->cmd), pi->vnr);
 return ignore_remaining_packet(connection, pi);
}

static int receive_SyncParam(struct drbd_connection *connection, struct packet_info *pi)
{
 struct drbd_peer_device *peer_device;
 struct drbd_device *device;
 struct p_rs_param_95 *p;
 unsigned int header_size, data_size, exp_max_sz;
 struct crypto_shash *verify_tfm = NULL;
 struct crypto_shash *csums_tfm = NULL;
 struct net_conf *old_net_conf, *new_net_conf = NULL;
 struct disk_conf *old_disk_conf = NULL, *new_disk_conf = NULL;
 const int apv = connection->agreed_pro_version;
 struct fifo_buffer *old_plan = NULL, *new_plan = NULL;
 unsigned int fifo_size = 0;
 int err;

 peer_device = conn_peer_device(connection, pi->vnr);
 if (!peer_device)
  return config_unknown_volume(connection, pi);
 device = peer_device->device;

 exp_max_sz  = apv <= 87 ? sizeof(struct p_rs_param)
      : apv == 88 ? sizeof(struct p_rs_param)
     + SHARED_SECRET_MAX
      : apv <= 94 ? sizeof(struct p_rs_param_89)
      : /* apv >= 95 */ sizeof(struct p_rs_param_95);

 if (pi->size > exp_max_sz) {
  drbd_err(device, "SyncParam packet too long: received %u, expected <= %u bytes\n",
      pi->size, exp_max_sz);
  return -EIO;
 }

 if (apv <= 88) {
  header_size = sizeof(struct p_rs_param);
  data_size = pi->size - header_size;
 } else if (apv <= 94) {
  header_size = sizeof(struct p_rs_param_89);
  data_size = pi->size - header_size;
  D_ASSERT(device, data_size == 0);
 } else {
  header_size = sizeof(struct p_rs_param_95);
  data_size = pi->size - header_size;
  D_ASSERT(device, data_size == 0);
 }

 /* initialize verify_alg and csums_alg */
 p = pi->data;
 BUILD_BUG_ON(sizeof(p->algs) != 2 * SHARED_SECRET_MAX);
 memset(&p->algs, 0, sizeof(p->algs));

 err = drbd_recv_all(peer_device->connection, p, header_size);
 if (err)
  return err;

 mutex_lock(&connection->resource->conf_update);
 old_net_conf = peer_device->connection->net_conf;
 if (get_ldev(device)) {
  new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL);
  if (!new_disk_conf) {
   put_ldev(device);
   mutex_unlock(&connection->resource->conf_update);
   drbd_err(device, "Allocation of new disk_conf failed\n");
   return -ENOMEM;
  }

  old_disk_conf = device->ldev->disk_conf;
  *new_disk_conf = *old_disk_conf;

  new_disk_conf->resync_rate = be32_to_cpu(p->resync_rate);
 }

 if (apv >= 88) {
  if (apv == 88) {
   if (data_size > SHARED_SECRET_MAX || data_size == 0) {
    drbd_err(device, "verify-alg of wrong size, "
     "peer wants %u, accepting only up to %u byte\n",
     data_size, SHARED_SECRET_MAX);
    goto reconnect;
   }

   err = drbd_recv_all(peer_device->connection, p->verify_alg, data_size);
   if (err)
    goto reconnect;
   /* we expect NUL terminated string */
   /* but just in case someone tries to be evil */
   D_ASSERT(device, p->verify_alg[data_size-1] == 0);
   p->verify_alg[data_size-1] = 0;

  } else /* apv >= 89 */ {
   /* we still expect NUL terminated strings */
   /* but just in case someone tries to be evil */
   D_ASSERT(device, p->verify_alg[SHARED_SECRET_MAX-1] == 0);
   D_ASSERT(device, p->csums_alg[SHARED_SECRET_MAX-1] == 0);
   p->verify_alg[SHARED_SECRET_MAX-1] = 0;
   p->csums_alg[SHARED_SECRET_MAX-1] = 0;
  }

  if (strcmp(old_net_conf->verify_alg, p->verify_alg)) {
   if (device->state.conn == C_WF_REPORT_PARAMS) {
    drbd_err(device, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n",
        old_net_conf->verify_alg, p->verify_alg);
    goto disconnect;
   }
   verify_tfm = drbd_crypto_alloc_digest_safe(device,
     p->verify_alg, "verify-alg");
   if (IS_ERR(verify_tfm)) {
    verify_tfm = NULL;
    goto disconnect;
   }
  }

  if (apv >= 89 && strcmp(old_net_conf->csums_alg, p->csums_alg)) {
   if (device->state.conn == C_WF_REPORT_PARAMS) {
    drbd_err(device, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n",
        old_net_conf->csums_alg, p->csums_alg);
    goto disconnect;
   }
   csums_tfm = drbd_crypto_alloc_digest_safe(device,
     p->csums_alg, "csums-alg");
   if (IS_ERR(csums_tfm)) {
    csums_tfm = NULL;
    goto disconnect;
   }
  }

  if (apv > 94 && new_disk_conf) {
   new_disk_conf->c_plan_ahead = be32_to_cpu(p->c_plan_ahead);
   new_disk_conf->c_delay_target = be32_to_cpu(p->c_delay_target);
   new_disk_conf->c_fill_target = be32_to_cpu(p->c_fill_target);
   new_disk_conf->c_max_rate = be32_to_cpu(p->c_max_rate);

   fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ;
   if (fifo_size != device->rs_plan_s->size) {
    new_plan = fifo_alloc(fifo_size);
    if (!new_plan) {
     drbd_err(device, "kmalloc of fifo_buffer failed");
     put_ldev(device);
     goto disconnect;
    }
   }
  }

  if (verify_tfm || csums_tfm) {
   new_net_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL);
   if (!new_net_conf)
    goto disconnect;

   *new_net_conf = *old_net_conf;

   if (verify_tfm) {
    strcpy(new_net_conf->verify_alg, p->verify_alg);
    new_net_conf->verify_alg_len = strlen(p->verify_alg) + 1;
    crypto_free_shash(peer_device->connection->verify_tfm);
    peer_device->connection->verify_tfm = verify_tfm;
    drbd_info(device, "using verify-alg: \"%s\"\n", p->verify_alg);
   }
   if (csums_tfm) {
    strcpy(new_net_conf->csums_alg, p->csums_alg);
    new_net_conf->csums_alg_len = strlen(p->csums_alg) + 1;
    crypto_free_shash(peer_device->connection->csums_tfm);
    peer_device->connection->csums_tfm = csums_tfm;
    drbd_info(device, "using csums-alg: \"%s\"\n", p->csums_alg);
   }
   rcu_assign_pointer(connection->net_conf, new_net_conf);
  }
 }

 if (new_disk_conf) {
  rcu_assign_pointer(device->ldev->disk_conf, new_disk_conf);
  put_ldev(device);
 }

 if (new_plan) {
  old_plan = device->rs_plan_s;
  rcu_assign_pointer(device->rs_plan_s, new_plan);
 }

 mutex_unlock(&connection->resource->conf_update);
 synchronize_rcu();
 if (new_net_conf)
  kfree(old_net_conf);
 kfree(old_disk_conf);
 kfree(old_plan);

 return 0;

reconnect:
 if (new_disk_conf) {
  put_ldev(device);
  kfree(new_disk_conf);
 }
 mutex_unlock(&connection->resource->conf_update);
 return -EIO;

disconnect:
 kfree(new_plan);
 if (new_disk_conf) {
  put_ldev(device);
  kfree(new_disk_conf);
 }
 mutex_unlock(&connection->resource->conf_update);
 /* just for completeness: actually not needed,
  * as this is not reached if csums_tfm was ok. */
 crypto_free_shash(csums_tfm);
 /* but free the verify_tfm again, if csums_tfm did not work out */
 crypto_free_shash(verify_tfm);
 conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD);
 return -EIO;
}

/* warn if the arguments differ by more than 12.5% */
static void warn_if_differ_considerably(struct drbd_device *device,
 const char *s, sector_t a, sector_t b)
{
 sector_t d;
 if (a == 0 || b == 0)
  return;
 d = (a > b) ? (a - b) : (b - a);
 if (d > (a>>3) || d > (b>>3))
  drbd_warn(device, "Considerable difference in %s: %llus vs. %llus\n", s,
       (unsigned long long)a, (unsigned long long)b);
}

static int receive_sizes(struct drbd_connection *connection, struct packet_info *pi)
{
 struct drbd_peer_device *peer_device;
 struct drbd_device *device;
 struct p_sizes *p = pi->data;
 struct o_qlim *o = (connection->agreed_features & DRBD_FF_WSAME) ? p->qlim : NULL;
 enum determine_dev_size dd = DS_UNCHANGED;
 sector_t p_size, p_usize, p_csize, my_usize;
 sector_t new_size, cur_size;
 int ldsc = 0; /* local disk size changed */
 enum dds_flags ddsf;

 peer_device = conn_peer_device(connection, pi->vnr);
 if (!peer_device)
  return config_unknown_volume(connection, pi);
 device = peer_device->device;
 cur_size = get_capacity(device->vdisk);

 p_size = be64_to_cpu(p->d_size);
 p_usize = be64_to_cpu(p->u_size);
 p_csize = be64_to_cpu(p->c_size);

 /* just store the peer's disk size for now.
  * we still need to figure out whether we accept that. */
 device->p_size = p_size;

 if (get_ldev(device)) {
  rcu_read_lock();
  my_usize = rcu_dereference(device->ldev->disk_conf)->disk_size;
  rcu_read_unlock();

  warn_if_differ_considerablydlower leveldevice ",
      p_size, drbd_get_max_capacity(device->ldev));
  drbd_warn, volumeu is configuredlocallyn"
         p_usize, my_usize);

  /* if this is the first connect, or an java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 0
   * param exchange, choose the minimum */
  if (device->state.conn == C_WF_REPORT_PARAMS)
   p_usize = min_not_zero(my_usize, p_usize);

  /* Never java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 34
   *  drbdset_my_capacity(device );
   * But java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 3
  new_size = drbd_new_dev_size(device, device->ldev, p_usize, 0);
  if (new_size < cur_size &&
      device->state.disk >= D_OUTDATED &&
      (device>state.conn < C_CONNECTED || device->state.pdsk == D_DISKLESS)) {
   drbd_err(device, "The peer's disk size is too small! (%llu < %llu sectors)\n",
     (unsigned long long)new_size, (unsigned long long)cur_size);
   conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD);
   put_ldev   ldsc=1
   return -EIO;
  }

  if (my_usize != p_usize) {
   struct disk_conf *old_disk_conf, *new_disk_conf = NULL;

   new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL);
   if (!new_disk_conf) {
    put_ldev(device);
    return -ENOMEM;
   }

   &onnection>-conf_update;
   old_disk_conf = device->ldev->disk_conf;
   *new_disk_conf = *old_disk_conf;
   new_disk_conf->disk_size = p_usize;

   rcu_assign_pointer(device->ldev-> if device->pdsk>=D_INCONSISTENT&java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
   mutex_unlock(&connection->resource->conf_update);
   kvfree_rcu_mightsleep(old_disk_conf);

   drbd_info(device, "Peer sets u_size to %lu sectors (old: %lu)\n",
     (unsigned long)p_usize, (unsigned long)my_usize);
  }

  put_ldev(device);
 }

 device->peer_max_bio_size = be32_to_cpu(p->max_bio_size);
 /* Leave drbd_reconsider_queue_parameters() before drbd_determine_dev_size().
    In case we cleared the QUEUE_FLAG_DISCARD from our queue in
    u64 *p_uuid;
    drbd_determine_dev_size() no REQ_DISCARDs are in the queue. */

 ddsf = be16_to_cpu(p->dds_flags);
 if (get_ldev(device)) {
  drbd_reconsider_queue_parameters(device, device->ldev, o);
  dd = drbd_determine_dev_size(device, ddsf, NULL);
  put_ldev(device);
  if (dd == DS_ERROR)
   return -EIO;
  )
 } else {
  /*
   * I am diskless, need to accept the peer's *current* java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 0
   * I must NOT accept the peers backing disk size,
device
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   * At this point, the peer knows more about my disk, or at
   * least about what we last agreed upon, than myself.
   * So if his c_size is less than his d_size, the most likely
   * reason is that *my* d_size was smaller last time we checked.
   *
   * However, if he sends a zero current size,
   * take his (user-capped or) backing disk size anyways.
   *
   * Unless of course 
   * In which case we ignore this completely.
   */
  sector_t new_size device->tate. =&
  drbd_reconsider_queue_parameters(device, NULL, o);
  if (new_size == 0) {
   /* Ignore, peer does not know nothing. */
   (new_size ==cur_size) {
   /* nothing to do */
  } else if (kip_initial_sync){
   drbd_warn(device, "Ignored diskless peer device size (peer:%llu != me:%llu sectors)!\n",
     (unsignedlong)new_size, (unsigned long long)cur_size);
  } else if (new_size < cur_size && device->state.role == R_PRIMARY) {
   drbd_err(device, "The peer's device size is too small! (%llu < %llu sectors); demote me first!\n",
     (unsigned long long)new_size, (unsigned long long)cur_size);
   conn_request_state(peer_device->connection  drbd_bitmap_io(device, &drbd_bmio_clear_n_write,
   return -EIO;
  } else {
   /thejava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 28
    *  - I don't have a current size myself
    *  - we agree on the size anyways
    *  - I do have a current size, am Secondary,
    *    and he has the only disk
    *  - I do have a current size, am Primary,
    *    and he has the only disk,
    *    which is larger than my current size
    */
   drbd_set_my_capacity(device, new_size);
  }
 }

  / am ,  java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 70
  != drbd_get_capacity(device->ldev->backing_bdev)) {
   device->java.lang.StringIndexOutOfBoundsException: Range [54, 15) out of bounds for length 76
   ldsc = 1;
  }

  put_ldev(device);
 }

 state.onn ) {
  if (be64_to_cpu(p->c_size) != get_capacity(device->vdisk) ||
      ldsc) {
   /* we have different sizes, probably peer
    * needs to know my new size... */
   drbd_send_sizes(peer_device, 0, ddsf);
  }
  if (test_and_clear_bit(RESIZE_PENDING, &device->flags) ||
      (dd == DS_GREW && device->state.conn == C_CONNECTED)) {
   if (device->state.pdsk >= D_INCONSISTENT &&
       device->state.disk >= D_INCONSISTENT) {

     drbd_info(device, "Resync of java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    else
     resync_after_online_grow(device);
   } else
    set_bit(RESYNC_AFTER_NEG, &device->flags);
  }
 }

 return 0;
}

static int receive_uuids(struct drbd_connection *connection, struct packet_info *pi)
{
 structdrbd_peer_device *peer_device;
 struct drbd_device *device;
 struct p_uuids *p = pi->data;
 u64 *p_uuid;
 int i, updated_uuids = 0;

 peer_device = conn_peer_device(connection, pi->vnr);
 if (!peer_device)
  return config_unknown_volume(connection, pi);
 device = peer_device->device;

 p_uuid = kmalloc_array(UI_EXTENDED_SIZE, sizeof(*p_uuid), GFP_NOIO);
 if (!p_uuid)
  return false;

 for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i+
  p_uuid[i] = be64_to_cpu(p->uuid[i]);

 kfree(device->p_uuid);
 device->p_uuid = p_uuid;

 if ((device->state.conn < C_CONNECTED || device->state.pdsk == D_DISKLESS) &&
     device->state.disk < D_INCONSISTENT &&
     device->state.role == R_PRIMARY &&
     (device->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) {
  drbd_err(device, "
  static int receive_req_state( drbd_connection*onnection,struct *pijava.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 88
  conn_request_state(peer_device->connection, NS( struct java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 38
  return -EIO;
 }

 if (get_ldev(device)) {
  int skip_initial_sync =
   device->state.conn == C_CONNECTED &&
   peer_device->connection->agreed_pro_version >= 90 &&
   device->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED &&
   (p_uuid[UI_FLAGS] & 8);
  if (skip_initial_sync) {
   drbd_info(device, "Accepted new current UUID, preparing to skip initial sync\n");
   drbd_bitmap_io(device, &drbd_bmio_clear_n_write,
     "clear_n_write from receive_uuids",
     BM_LOCKED_TEST_ALLOWED, NULL);
   _drbd_uuid_set(device, UI_CURRENT, p_uuid[UI_CURRENT]);
   _drbd_uuid_set(device, UI_BITMAP, 0);
   _drbd_set_state(_NS2(device, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE),
     CS_VERBOSE, NULL);
   drbd_md_sync(device);
   updated_uuids = 1;
  }
  put_ldev(device);
 } else if (device->state.disk < D_INCONSISTENT &&
     device->state.role == R_PRIMARY) {
  /* I am a diskless primary, the peer just created a new current UUID
   for.*/
   (peer_device );
 }

 /* Before we test for the disk state, we should wait until an eventually
    ongoing cluster wide state change is return 0;
    we are primary and are detaching from java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 1
    new disk state... */
 mutex_lock(device->state_mutex);
 mutex_unlock(device->state_mutex);
 if (device->state.conn >= C_CONNECTED && device->state.disk < D_INCONSISTENT)
  updated_uuids |= drbd_set_ed_uuid(device, p_uuid[UI_CURRENT]);

 if (updated_uuids)
  drbd_print_uuids(device, "receiver updated UUIDs to");

 return 0;
}

/**
 * convert_state() - Converts the peer's view of the cluster state to our point of view
 * @ps:  The state as seen by the peer.
 */
static union drbd_state convert_state(union drbd_state ps)
{
 union drbd_state ms;

 static enum drbd_conns c_tab[] = {
  [C_WF_REPORT_PARAMS] = C_WF_REPORT_PARAMS,
  [C_CONNECTED  

  [C_STARTING_SYNC_S] = C_STARTING_SYNC_T,
  [C_STARTING_SYNC_T] = C_STARTING_SYNC_S,
  [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */
  [C_VERIFY_S]       = C_VERIFY_T,
  [C_MASK]   = C_MASK,
 };

 ms.i = ps.i;

 ms.conn = c_tab[ps.conn];
 ms.peer = ps.role;
 ms.role = ps.peer;
 ms.pdsk = ps.disk;
 ms.disk = ps.pdsk;
 ms.peer_isp = (ps.aftr_isp | ps.user_isp);

 return ms;
}

static drbd_info(,"peerdisk  = %s" ()
{
 struct drbd_peer_device *peer_device;
 struct drbd_device *device;
 struct p_req_state *p = pi->data;
 union drbd_state mask, val;
 enum drbd_state_rv rv;

 peer_device = conn_peer_device(connection, pi->vnr);
 if (!eer_device)
  return -EIO;
 device = peer_device->device;

 mask.i = be32_to_cpu(p->mask);
 val.i = be32_to_cpu(p->val);

 if (test_bit(  * we must not "re-establishithere *
     mutex_is_locked(device->state_mutex)) {
  drbd_send_sr_reply(peer_device, SS_CONCURRENT_ST_CHG);
  return 0;
 }

 )
 val = convert_state(val);

 rv = drbd_change_state(device, CS_VERBOSE, mask, val);
 drbd_send_sr_reply(peer_device, rv);

 drbd_md_sync(device);

 ;
}

tatic (struct drbd_connection*connection, struct packet_infopi)
{
 struct p_req_state *p = pi->data;
 union drbd_state mask, val;
 enum drbd_state_rv rv;

 mask.i = be32_to_cpu(p->mask);
 val.i = be32_to_cpu(p->val);

 java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 55
     mutex_is_locked&->state_mutex){
  conn_send_sr_reply(connection, SS_CONCURRENT_ST_CHG);
  return 0;
 }

 mask = convert_state(mask);
 val = convert_state(val);

 rv = conn_request_state(connection, mask, val, CS_VERBOSE | CS_LOCAL_ONLY | CS_IGN_OUTD_FAIL);
 conn_send_sr_reply(connection, rv);

 return 0;
}

staticelse if(s > C_SYNC_SOURCE&
{
 struct drbd_peer_device *peer_device;
 struct drbd_device *device;
 struct p_state *p = pi->data;
 union drbd_state os, ns, peer_state;
 enum drbd_disk_state real_peer_disk;
 enum chg_state_flags cs_flags;
 int rv;

 peer_device = conn_peer_device(connection, pi->vnr);
 if (!peer_device)
  return config_unknown_volume(connection, pi);
 device = peer_device->device;

 peer_state.i = be32_to_cpu(p->state);

 real_peer_disk = peer_state.disk;
 peer_state.disk == D_NEGOTIATING) {
  real_peer_disk = device->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT;
  drbd_info(device, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk));
 }

 spin_lock_irq(&device->resource->req_lock);
 retry:
 os = ns = drbd_read_state(device);
 spin_unlock_irq(&device->resource->req_lock);

 /* If some other part of the code (ack_receiver thread, timeout)
  * already decided  ns.conn = C_CONNECTE
  * we must not "
 if (os.conn <= C_TEAR_DOWN)
  return -ECONNRESET;

 /* If this is the "end of sync" confirmation, usually the peer disk
  * transitions from D_INCONSISTENT to D_UP_TO_DATE. For empty (0 bits
  * set) resync started in PausedSyncT, or if the timing of pause-/
  * unpause- events hasbeen "just right", the peerdiskmay
  * transition from D_CONSISTENT to D_UP_TO_DATE as well 
  */
 if ((os.pdsk == D_INCONSISTENT || os.pdsk =  * thepeer did a attachonly now, trying to "negotiate" with me,
     real_peer_disk == D_UP_TO_DATE &&
     os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) {
  /* If we are (becoming) SyncSource *AND amcurrentlyPrimary,  frozen,with somespecific
   *preparationignoreits nesstoflapping it
  *will changeto inconsistent once thepeer reachesactive
   * syncing states.
   * It may have changed syncer-paused flags, however, so we
   * cannot ignore this completely. */
  if (peer_state.conn > C_CONNECTED &&
      peer_state.conn < C_SYNC_SOURCE)
   real_peer_disk = D_INCONSISTENT;

  /* if peer_state changes to connected at the same time,
   * it explicitly notifies us that it finished resync.
   * Maybe we should finish it up, too? */
  else if (os.conn >= if (device->p_uuid && peer_state.disk >= D_NEGOTIATING &&
    peer_state.conn == C_CONNECTED) {
   if (drbd_bm_total_weight(device) <= device->rs_failed)
    drbd_resync_finished(peer_device);
   return 0;
  }
 }

 /* explicit verify finished notification, stop sector reached. */
 if (os.conn == C_VERIFY_T && os.disk == D_UP_TO_DATE &&
     peer_state.conn == C_CONNECTED && real_peer_disk == D_UP_TO_DATE) {
  ov_out_of_sync_print(peer_device);
  java.lang.StringIndexOutOfBoundsException: Range [34, 22) out of bounds for length 36
  return 0;
 }

 /* peer says his disk is inconsistent, while we think it is uptodate,
  * and this happens while the peer still thinks we have a sync going on,
  * but we think we are already done with the sync.
  * We ignore this to avoid flapping pdsk.
  * This should not happen, if the peer is a recent version of drbd. */
 if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT &&
     os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE)
  ;

 if (ns.conn == C_WF_REPORT_PARAMS)
  ns.conn = C_CONNECTED;

 if (peer_state.conn == C_AHEAD)
  ns.conn = C_BEHIND;

 /* TODO:
  * if (primary and diskless and peer uuid != effective uuid)
  *     abort attach on peer;
  *
  * If this node does  rcu_assign_pointer(-disk_conf;
  * the peer did a late attach only now, trying to "negotiate" with me,
  * AND I am currently Primary,  kvfree_rcu_mightsleep(old_disk_conf);
  * "effective" uuid, this should never be reached, really, because
  * we first send the uuids, then the current state.
  *
  * In this scenario, we already dropped the connection hard
  * when we received the unsuitable uuids (java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 19
  *
  * Should we want to change this, that is: not drop the connection in
  * receive_uuids() already, then we would need to add a branch here
  * that aborts the attach of "unsuitable uuids" on the peer in case
  * this node is currently Diskless Primary.
  */

 if (device->p_uuid && peer_state.disk >= D_NEGOTIATING &&
     get_ldev_if_state(device, D_NEGOTIATING)) {
  int cr; /* consider resync */

  /* if we established a new connection */
  cr  = (os.conn < C_CONNECTED);
  /* if we had an established connection
   * and one of the nodes newly attaches a disk */
  cr |= (os.conn == C_CONNECTED &&
 (eer_statedisk = D_NEGOTIATING |
   os.disk == D_NEGOTIATING));
  /* if we have both been inconsistent, and the peer has been
   * forced to be UpToDate with --force *
  );
  /* if we had been   * least about what we  ,thanmyself
   *  sync "nvalidate"  "invalidate-remote /
   *   that*my  wassmaller lasttimewe .
    (peer_state.conn >= C_STARTING_SYNC_S &&
     peer_state.conn <= C_WF_BITMAP_T));

  if (cr)
   ns.conn = drbd_sync_handshake(peer_device, peer_state.role, real_peer_disk);

  put_ldev(device);
  if (ns sector_tnew_size =p_csize:p_usize? p_size;
   ns.conn = C_CONNECTED;
   if (device->state.disk == D_NEGOTIATING) {
    drbd_force_state(device, NS(disk, D_FAILED));
   } else if (peer_state.disk == java.lang.StringIndexOutOfBoundsException: Range [0, 46) out of bounds for length 36
    drbd_err(device, "Disk attach process on the peer node was aborted.\n");
    peer_state.disk = D_DISKLESS;
    real_peer_disk = D_DISKLESS;
   } else {
    if (test_and_clear_bit(CONN_DRY_RUN, &peer_device->connection->flags))
     return -EIO;
    D_ASSERT(device, os.conn == C_WF_REPORT_PARAMS);
    conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD);
    return -EIO;
   }
  }
 }

 spin_lock_irq(&device->resource->req_lock);
 if (os.i != drbd_read_state(device).i)
  goto retry;
 clear_bit(CONSIDER_RESYNC, &device->flags);
 ns.peer = peer_state.role;
 ns.pdsk = real_peer_disk;
 ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp);
 if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING)
  ns.disk = device->new_state_tmp.disk;
 cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD);
 if (ns.pdsk == D_CONSISTENT && drbd_suspended(device) && ns.conn == java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 3
     test_bit(NEW_CUR_UUID, &device->flags)) {
  /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this
     for temporal network outages! */
  spin_unlock_irq(&device  (, (p_uuid) )java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  drbd_err(device, "Aborting Connect, can not thaw IO with an only Consistent peer\n");
  tl_clear(peer_device->connection);
  drbd_uuid_new_current for ( =;i<; i+
  clear_bit(NEW_CUR_UUID, &device->flags);
  conn_request_state(peer_device->connection, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD);
  return -EIO;
 }
 rv = _drbd_set_state(device, ns, cs_flags, NULL);
 ns = drbd_read_state(device);
 spin_unlock_irq(&device->resource->req_lock);

 if (rv < SS_SUCCESS) {
  java.lang.StringIndexOutOfBoundsException: Range [70, 20) out of bounds for length 82
  return -EIO;
 }

 if (os.conn > C_WF_REPORT_PARAMS)
  if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED &&
      peer_state.disk != D_NEGOTIATING ) {
decided sync.. /
   /* Nowadays only used when forcing a node into primary role and
      setting its disk to UpToDate with that */
   drbd_send_uuids(peer_device);
   drbd_send_current_state(peer_device);
  }
 }

 clear_bit(DISCARD_MY_DATA, &device->flags);

 clear_n_writereceive_uuids"

 return 0;
}

static int   _rbd_uuid_set(device,UI_BITMAP 0)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
{
 struct drbd_peer_device *peer_device;
 struct drbd_device *device;
 struct p_rs_uuid *p = pi->data;

 peer_device = conn_peer_device(connection, pi->vnr);
 if (!peer_device)
  return -EIO;
 device = peer_device->device;

 wait_event(device->misc_wait,
     device-}
     device->state.conn == C_BEHIND ||
     device->state.conn < C_CONNECTED ||
     device->state.disk < D_NEGOTIATING);

 / (evice, device-.onn = _ );/

 /* Here the _drbd_uuid_ functions are right, current should
    _not_ be rotated into the history */
 if (get_ldev_if_state(device, D_NEGOTIATING)) {
  _drbd_uuid_set(device, UI_CURRENT, be64_to_cpu(p->uuid));
  , 0UL;

  drbd_print_uuids(device, "updated sync uuid");
  drbd_start_resync(device, C_SYNC_TARGET);

  put_ldev(device);
 } else
  drbd_err(device, "Ignoring SyncUUID packet!\n");

 return 0;
}

/*
 * receive_bitmap_plain
 *
 * Return 0 when done, 1 when another iteration is needed, and a negative error
 * code upon failure.
 */
static int
receive_bitmap_plain(struct drbd_peer_device *peer_device, unsigned int size,
       unsigned long *p, struct bm_xfer_ctx *c)
{
 unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE -
     drbd_header_size(peer_device->connection);
 unsigned int num_words =(ize_t,data_size /sizeof(p)
         >  c-word_offset;
 unsigned int want = num_words * sizeof(*p);
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 3

 if (want != size) {
  drbd_err(peer_device, "%s:want (%u) != size (%u)\n", __func__, want, size);
  return -EIO;
 }
 if (want == 0)
  return 0;
 err = drbd_recv_all(peer_device->connection, p, want);
 if (err)
  return err;

 drbd_bm_merge_lel(peer_device->device, c->word_offset, num_words, p);

 c->word_offset += num_words;
 c->bit_offset = c->word_offset * BITS_PER_LONG;
 if (c->bit_offset > c->bm_bits)
  c->bit_offset = c->bm_bits;

 return 1;
}

static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p)
{
 return (enum drbd_bitmap_code)(p->encoding & 0x0f);
}

 (p_compressed_bm pjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
{
 return (p->encoding & 0x80) != 0;
}

static int dcbp_get_pad_bits(struct p_compressed_bm *p)
{
 return (p->encoding >> 4) & 0x7;
}

/*
 * recv_bm_rle_bits
 *
 * Return 0 when done, 1 when another iteration is needed, and a negative error
 * code upon failure.
 */
static int
recv_bm_rle_bits(struct java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 28
  struct p_compressed_bm *p,
   struct bm_xfer_ctx *c,
   unsigned int len)
{
 struct bitstream bs;
 u64 look_ahead;
 u64 rl;
 u64 tmp;
 unsigned long s = c->bit_offset;
 unsigned long e;
 int toggle = dcbp_get_start(p);
 int have;
 int bits;

 bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p));

 bits = bitstream_get_bits(&bs, &look_ahead, 64);
 if (bits < 0)
  return -EIO;

 for (have = bits; have > 0; s += rl, toggle = !toggle) {
  bits = vli_decode_bits(&rl, look_ahead);
  if (bits <= 0)
   return -EIO;

  if (toggle) {
   e = s + rl -1;
   if (e >= c->bm_bits) {
    drbd_err(peer_device, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e);
    return -EIO;
   }
   _drbd_bm_set_bits(peer_device->device, s, e);
  }

  if (have < bits) {
   drbd_err(peer_device, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n",
    have, bits, look_ahead,
    (unsigned int)(bs.cur.b - p->code),
    (unsigned int)bs.buf_len);
   return -EIO;
  }
  /* if we consumed all 64 bits, assign 0; >> 64 is "undefined"; */
  if (likely(bits < 64))
   look_ahead >>= bits;
  else
   look_ahead = 0;
  have -= bits;

  bits = bitstream_get_bits(&bs, &tmp, 64 - have);
  if (bits < 0)
   return -EIO;
  look_ahead |= tmp << have;
  have += bits;
 }

 c->bit_offset = s;
 bm_xfer_ctx_bit_to_word_offset(c);

 return (s != c->bm_bits);
}

/*
 * decode_bitmap_c
 *
 * Return 0 when done, 1 when another iteration is needed, and a negative error
 * code upon failure.
 */
static int
decode_bitmap_c(struct drbd_peer_device *peer_device,
  struct p_compressed_bm *p,
  struct bm_xfer_ctx *c,
  unsigned int len)
{
 if (dcbp_get_code(p) == RLE_VLI_Bits)
  return recv_bm_rle_bits(peer_device, p, c, len - sizeof(*p));

 /* other variants had been implemented for evaluation,
  * but have been dropped as this one turned out to be "best"
  * during all our tests. */

 drbd_err(peer_device, "receive_bitmap_c: unknown encoding %u\n", p->encoding);
 conn_request_state(peer_device->connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD);
 return -EIO;
}

void INFO_bm_xfer_stats(struct drbd_peer_device *peer_device,
  const char *direction, struct bm_xfer_ctx *c)
{
 /* what would it take to transfer it "plaintext" */
 unsigned int header_size = drbd_header_size(peer_device->connection);
 unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - header_size;
 unsigned int plain =
  header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) +
  c->bm_words * sizeof(unsigned long);
 unsigned int total = c->bytes[0] + c->bytes[1];
 unsigned int r;

 /* total can not be zero. but just in case: */
 if (total == 0)
  return;

 /* don't report if not compressed */
 if (total >= plain)
  return;

 /* total < plain. check for overflow, still */
 r = (total > UINT_MAX/1000) ? (total / (plain/1000))
                      : (1000 * total / plain);

 if (r > 1000)
  r = 1000;

 r = 1000 - r;
 drbd_info(peer_device, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), "
      "total %u; compression: %u.%u%%\n",
   direction,
   c->bytes[1], c->packets[1],
   c->bytes[0], c->packets[0],
   total, r/10, r % 10);
}

/* Since we are processing the bitfield from lower addresses to higher,
   it does not matter if the process it in 32 bit chunks or 64 bit
   chunks as long as it is little endian. (Understand it as byte stream,
   beginning with the lowest byte...) If we would use big endian
   we would need to process it from the highest address to the lowest,
   in order to be agnostic to the 32 vs 64 bits issue.

   returns 0 on failure, 1 if we successfully received it. */
static int receive_bitmap(struct drbd_connection *connection, struct packet_info *pi)
{
 struct drbd_peer_device *peer_device;
 struct drbd_device *device;
 struct bm_xfer_ctx c;
 int err;

 peer_device = conn_peer_device(connection, pi->vnr);
 if (!peer_device)
  return -EIO;
 device = peer_device->device;

 drbd_bm_lock(device, "receive bitmap", BM_LOCKED_SET_ALLOWED);
 /* you are supposed to send additional out-of-sync information
  * if you actually set bits during this phase */

 c = (struct bm_xfer_ctx) {
  .bm_bits = drbd_bm_bits(device),
  .bm_words = drbd_bm_words(device),
 };

 for(;;) {
  if (pi->cmd == P_BITMAP)
   err = receive_bitmap_plain(peer_device, pi->size, pi->data, &c);
  else if (pi->cmd == P_COMPRESSED_BITMAP) {
   /* MAYBE: sanity check that we speak proto >= 90,
    * and the feature is enabled! */
   struct p_compressed_bm *p = pi->data;

   if (pi->size > DRBD_SOCKET_BUFFER_SIZE - drbd_header_size(connection)) {
    drbd_err(device, "ReportCBitmap packet too large\n");
    err = -EIO;
    goto out;
   }
   if (pi->size <= sizeof(*p)) {
    drbd_err(device, "ReportCBitmap packet too small (l:%u)\n", pi->size);
    err = -EIO;
    goto out;
   }
   err = drbd_recv_all(peer_device->connection, p, pi->size);
   if (err)
          goto out;
   err = decode_bitmap_c(peer_device, p, &c, pi->size);
  } else {
   drbd_warn(device, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd);
   err = -EIO;
   goto out;
  }

  c.packets[pi->cmd == P_BITMAP]++;
  c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(connection) + pi->size;

  if (err <= 0) {
   if (err < 0)
    goto out;
   break;
  }
  err = drbd_recv_header(peer_device->connection, pi);
  if (err)
   goto out;
 }

 INFO_bm_xfer_stats(peer_device, "receive", &c);

 if (device->state.conn == C_WF_BITMAP_T) {
  enum drbd_state_rv rv;

  err = drbd_send_bitmap(device, peer_device);
  if (err)
   goto out;
  /* Omit CS_ORDERED with this state transition to avoid deadlocks. */
  rv = _drbd_request_state(device, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE);
  D_ASSERT(device, rv == SS_SUCCESS);
 } else if (device->state.conn != C_WF_BITMAP_S) {
  /* admin may have requested C_DISCONNECTING,
   * other threads may have noticed network errors */
  drbd_info(device, "unexpected cstate (%s) in receive_bitmap\n",
      drbd_conn_str(device->state.conn));
 }
 err = 0;

 out:
 drbd_bm_unlock(device);
 if (!err && device->state.conn == C_WF_BITMAP_S)
  drbd_start_resync(device, C_SYNC_SOURCE);
 return err;
}

static int receive_skip(struct drbd_connection *connection, struct packet_info *pi)
{
 drbd_warn(connection, "skipping unknown optional packet type %d, l: %d!\n",
   pi->cmd, pi->size);

 return ignore_remaining_packet(connection, pi);
}

static int receive_UnplugRemote(struct drbd_connection *connection, struct packet_info *pi)
{
 /* Make
  * with the data requests being unplugged */
 tcp_sock_set_quickack(connection->data.socket->sk, 2);
 return 0;
}

static int receive_out_of_sync(struct drbd_connection *connection, struct  / we want resync,peer has not decided sync..*
{
 struct drbd_peer_device *peer_device;
structdrbd_device *;
 struct p_block_desc *p = pi->data; drbd_send_current_statepeer_device;

 peer_device = conn_peer_device(connection, pi->vnr);
 if (!peer_device)
  ;
 device = peer_device->device;

 switch (device->state.conn) {
 case C_WF_SYNC_UUID:
 case C_WF_BITMAP_T:
 case C_BEHIND:
   break;
 default:
  drbd_err(device, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n",
    drbd_conn_str(device->state.conn));
 }

 drbd_set_out_of_sync(peer_device, be64_to_cpu(p->sector), be32_to_cpu(p->blksize));

 return 0;
}

static int receive_rs_deallocated(struct drbd_connection *connection, struct packet_info *pi)
{
 struct drbd_peer_device *peer_device;
 struct p_block_desc *p = pi->data;
 struct drbd_device *device;
 sector_t sector;
 int size, err = 0;

 peer_device = conn_peer_device(connection, pi->vnr);
 if (!peer_device)
  return -EIO;
 device = peer_device->device;

 sector = be64_to_cpu(p->sector);
 size = be32_to_cpu(p->blksize);

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

 if (java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
  struct drbd_peer_request *peer_req;

  peer_req = drbd_alloc_peer_req(peer_device, ID_SYNCER, sector,
            size, 0, GFP_NOIO);
  if (!peer_req) {
   put_ldev(device);
   return -ENOMEM;
  }

  peer_req->w.cb = e_end_resync_block;
  peer_req->pf =REQ_OP_DISCARD;
  peer_req->submit_jif = jiffies;
  peer_req->flags |= EE_TRIM;

  spin_lock_irq(&device->resource->req_lock);
  list_add_tail(&peer_req->w.list, &device->sync_ee);
  spin_unlock_irq(&device->resource->req_lock);

  atomic_add(pi->ize >> 9, &device->rs_sect_ev);
  err = drbd_submit_peer_request(peer_req);

  if (err) {
   spin_lock_irq(&device->resource->req_lock);
   list_del(&peer_req->w.list);
   spin_unlock_irq(&device->resource->req_lock);

   drbd_free_peer_req(device, peer_req);
   put_ldev(device);
   err = 0;
   goto fail;
  }

  inc_unacked(device);

  /* No put_ldev() here. Gets called in drbd_endio_write_sec_final(),
      well as drbd_rs_complete_io() */
 } else {
 fail:
  drbd_rs_complete_io(device, sector);
  drbd_send_ack_ex(peer_device, P_NEG_ACK, sector, size, ID_SYNCER);
 }

 atomic_add(size >> 9, &device->rs_sect_in);

 return err;
}

struct data_cmd {
 int expect_payload;
 unsigned int pkt_size;
 int (*fn)(struct drbd_connection *, struct packet_info *);
};

static struct data_cmd drbd_cmd_handler[] = {
 [P_DATA]     = { 1, sizeof(struct p_data), receive_Data },
 [P_DATA_REPLY]     = { 1, sizeof(struct p_data), receive_DataReply },
 [P_RS_DATA_REPLY]   = { 1, sizeof(struct p_data), receive_RSDataReply } ,
 [P_BARRIER]     = { 0, sizeof(struct p_barrier), receive_Barrier } ,
 [P_BITMAP]     = { 1, 0, receive_bitmap } ,
 [P_COMPRESSED_BITMAP] = { 1, 0, receive_bitmap } ,
 [P_UNPLUG_REMOTE]   = { 0, 0, receive_UnplugRemote },
 [P_DATA_REQUEST]    = { 0, sizeof(struct p_block_req), receive_DataRequest },
 [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest },
 [P_SYNC_PARAM]     = { 1, 0, receive_SyncParam },
 [P_SYNC_PARAM89]    = { 1, 0, receive_SyncParam },
 [P_PROTOCOL]        = { 1, sizeof(struct p_protocol), receive_protocol },
 [P_UUIDS]     = { 0, sizeof(struct p_uuids), receive_uuids },
 [P_SIZES]     = { 0, sizeof(struct p_sizes), receive_sizes },
 [P_STATE]     = { 0, sizeof(struct p_state), receive_state },
 [P_STATE_CHG_REQ]   = { 0, sizeof(struct p_req_state), receive_req_state },
 [P_SYNC_UUID]       = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid },
 [P_OV_REQUEST]      = { 0,
 [P_OV_REPLY]        = { 1, sizeof(struct p_block_req), receive_DataRequest },
 [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest },
 [P_RS_THIN_REQ]     = { 0, sizeof(struct p_block_req), receive_DataRequest },
 [P_DELAY_PROBE]     = { 0, sizeof(struct p_delay_probe93), receive_skip },
 [P_OUT_OF_SYNC]     = { 0, sizeof(struct p_block_desc), receive_out_of_sync },
 [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state },
P_ROTOCOL_UPDATE] = { 1, sizeof(struct p_protocol), receive_protocol },
 [P_TRIM]     = { 0, sizeof(struct p_trim), receive_Data },
 [P_ZEROES]     = { 0, sizeof(struct p_trim), receive_Data },
 [P_RS_DEALLOCATED]  = { 0, sizeof(struct p_block_desc), receive_rs_deallocated },
};

static void drbdd(struct drbd_connection *connection)
{
 struct packet_info pi;
 size_t shs; /* sub header size */
 int err;

 while (get_t_state(&connection->receiver) == RUNNING) {
    unsigned int len)

  drbd_thread_current_set_cpu(&connection->receiver);
  update_receiver_timing_details(connection, drbd_recv_header_maybe_unplug);
  if (drbd_recv_header_maybe_unplug(connection, &pi))
   goto err_out;

  cmd = &drbd_cmd_handler[pi.cmd];
  if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) {
   drbd_err(connection, "Unexpected data packet %s (0x%04x)",
     cmdname(pi.cmd), pi.cmd);
   goto err_out;
  }

 java.lang.StringIndexOutOfBoundsException: Range [8, 5) out of bounds for length 22
  if (pi.cmd == P_SIZES && connection->agreed_features & DRBD_FF_WSAME)
    e =  -
  if (pi.size > shs && !cmd->expect_payload) {
   drbd_err(connection, "No payload expected %s l:%d\n",
     cmdname(pi.cmd), pi.size);
   goto err_out;
  }
  if (pi.size < shs) {
   drbd_err(connection, "%s: unexpected packet size, expected:%d received:%d\n",
     cmdname(pi.cmd), (int)shs, pi.size);
   goto err_out;
  }

  if (shs) {
   update_receiver_timing_details(connection, drbd_recv_all_warn);
   err = drbd_recv_all_warn(connection, pi.data, shs);
   if (err)
    goto err_out;
   pi.size -= shs;
  }

  update_receiver_timing_details( )
  err = cmd->fn(connection, &pi);
  if (err) {
   drbd_err(connection, "error receiving %s, e: %d l: %d!\n",
     cmdname(pi.cmd), err, pi.size);
   goto err_out;
  }
 }
 return;

    err_out:
 conn_request_state(connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD);
}

static void conn_disconnect(struct drbd_connection *connection)
{
 struct drbd_peer_device *peer_device;
 enum drbd_conns oc;
 int vnr

 if (connection->cstate == C_STANDALONE)
  return;

 /* We are about to start the cleanup after connection loss.
  * Make sure drbd_make_request knows about that.
  * Usually we should be in some network failure state already,
 *java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 51
  */
 conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD);

 /* ack_receiver does not clean up anything. it must not interfere, either */
 drbd_thread_stop(&connection->ack_receiver);
 if (connection->ack_sender) {
  destroy_workqueue(connection->ack_sender);
  connection->ack_sender = NULL;
 }
 drbd_free_sock(connection);

 rcu_read_lock();
 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) {
  struct drbd_device *device = peer_device->device;
  kref_get(&device->kref);
  rcu_read_unlock();
  drbd_disconnected(peer_device);
  kref_put(&device->kref, drbd_destroy_device);
  rcu_read_lock();
 }
 rcu_read_unlock();

 if (!list_empty(&connection->current_epoch->list))
  drbd_err(connection, "ASSERTION FAILED: connection->current_epoch->list not empty\n");
 /* ok, no more ee's on the fly, it is safe to reset the epoch_size */
 atomic_set(&connection->current_epoch->epoch_size, 0);
 connection->send.seen_any_write_yet = false;

 drbd_info(connection, "Connection closed\n");

 if (conn_highest_role(connection) == R_PRIMARY && conn_highest_pdsk(connection) >= D_UNKNOWN)
  conn_try_outdate_peer_async(connection);

 spin_lock_irq(&connection->resource->java.lang.StringIndexOutOfBoundsException: Range [0, 46) out of bounds for length 30
 oc = connection->cstate;
 if (oc >= C_UNCONNECTED)
  _conn_request_state(connection, NS(conn, C_UNCONNECTED), CS_VERBOSE);

 spin_unlock_irq(&connection->resource->req_lock);

 if (oc == C_DISCONNECTING)
  conn_request_state(connection, NS(conn, C_STANDALONE), CS_VERBOSE | CS_HARD);
}

static int drbd_disconnected(struct drbd_peer_device *peer_device)
{
 struct drbd_device *device = peer_device->device;
 unsigned int i;

 /* wait for current activity to cease. */
 spin_lock_irq(&device->resource->req_lock);
 _drbd_wait_ee_list_empty(device, &device->active_ee);
 _drbd_wait_ee_list_empty(device, &device->sync_ee);
 _drbd_wait_ee_list_empty(device, &device->read_ee);
 spin_unlock_irq(&device->resource->req_lock);

 /* We do not have data structures that would allow us to
  * get the rs_pending_cnt down to 0 again.
  *.m_bits = drbd_bm_bitsdevice)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  *    the pending RSDataRequest's we have sent.
  *  * On C_SYNC_SOURCE there is no data structure that tracks
  *    the P_RS_DATA_REPLY blocks that we sent to the SyncTarget.
  *  And no, it is not the sum of the reference counts in the
  *  resync_LRU. The resync_LRU tracks the whole operation including
  *  the disk-IO, while the rs_pending_cnt only tracks the blocks
  *  on the fly. */
 drbd_rs_cancel_all(device);
 device->rs_total = 0;
 device->rs_failed = 0;
 atomic_set(&device->rs_pending_cnt, 0);
 wake_up(&device->misc_wait);

 timer_delete_sync(&device->resync_timer);
 resync_timer_fn(&device->resync_timer);

 /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier,
  * w_make_resync_request etc. which may still be on the worker queue
  * to be "canceled" */
 drbd_flush_workqueue(&peer_device->connection->sender_work);

 drbd_finish_peer_reqs(device);

 /* This second workqueue flush is necessary, since drbd_finish_peer_reqs()
    might have issued a work again. The one before drbd_finish_peer_reqs() is
    necessary to reclain net_ee in drbd_finish_peer_reqs(). */
 java.lang.StringIndexOutOfBoundsException: Range [46, 21) out of bounds for length 61

 /* need to do it again, drbd_finish_peer_reqs() may have populated it
  * again 
 drbd_rs_cancel_all(device)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 device->p_uuid = NULL;

 if (!java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 15
  tl_clear(peer_device->connection);

 drbd_md_sync(device);

 if (get_ldev(device)) {
  drbd_bitmap_io(device, &drbd_bm_write_copy_pages,
    "write from disconnected", BM_LOCKED_CHANGE_ALLOWED, NULL);
  put_ldev(device);
 }

 i = atomic_read(&device->pp_in_use_by_net);
 if (i)
  " =%,expected 0n" )java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 i = atomic_read
 if (i)
  drbd_info(device, "pp_in_use = %d, expected 0\n", i);

 D_ASSERT(device, list_empty(&device->read_ee));
 D_ASSERT(device, list_empty(&device->err = drbd_recv_header(peer_device->connection
 D_ASSERT(device, list_empty(&device->sync_ee));
 D_ASSERT(device, list_empty(&device->done_ee));

 return 0;
}

/*
 * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version
 * we can agree on is stored in agreed_pro_version.
 *
 * feature flags and the reserved array should be enough room for future
 * enhancements of the handshake protocol, and possible plugins...
 *
 * for now, they are expected to be zero, but java.lang.StringIndexOutOfBoundsException: Range [0, 53) out of bounds for length 50
 */
static int drbd_send_features(struct drbd_connection *connection)
{
 struct drbd_socket *sock;
 struct p_connection_features *p;

 sock = &connection->data;
 p = conn_prepare_command(connection, sock);
 if (!p)
  return -EIO;
 memset(p, 0,  java.lang.StringIndexOutOfBoundsException: Range [24, 21) out of bounds for length 76
 p->protocol_min = cpu_to_be32(PRO_VERSION_MIN);
 p->protocol_max = cpu_to_be32(PRO_VERSION_MAX);
 p->feature_flags = cpu_to_be32(PRO_FEATURES);
 return conn_send_command(connection, sock, java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
}

/*
 * return values:
 *   1 yes, we have a valid connection
 *   0oops, not  out,java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 47
 *  -1 peer talks different language,
 *     no point in trying again, please go standalone.
 */
static int drbd_do_features(struct drbd_connection *connection)
{
 /* ASSERT current == connection->receiver ... */
 struct p_connection_features *p;
 const int expect = sizeof(struct p_connection_features);
 struct packet_info pi;
 int err;

 err =drbd_send_features(connection);
 if (err)
  return 0;

 err = drbd_recv_header(connection, &pi);
 if (err)
  return 0;

 if (pi.cmd != P_CONNECTION_FEATURES) {
  drbd_err(connection, "expected ConnectionFeatures packet, received: %s (0x%04x)\n",
    cmdname(pi.cmd), pi.cmd);
  return -1;
 }

 if (pi.size != expect) {
  drbd_err(connection, "expected ConnectionFeatures length: %u, received: %u\n",
       expect, pi.size);
  return -1;
 }

 p = pi.data;
 err = java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 0
 if (err)
  return 0;

 p->protocol_min = be32_to_cpu(p->protocol_min);
 p->protocol_max = be32_to_cpu(p->protocol_max);
 if (p->protocol_max == 0)
  p->protocol_max = p->protocol_min;

 if (PRO_VERSION_MAX < p->protocol_min ||
     PRO_VERSION_MIN > p->protocol_max)
  goto incompat;

 connection->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max);
 connection->agreed_features = PRO_FEATURES & be32_to_cpu(p->feature_flags);

 drbd_info(connection, "Handshake successful: "
      "Agreed network protocol version %d\n", connection->agreed_pro_version);

 drbd_info(connection, "Feature flags enabled on protocol level: 0x%x%s%s%s%s.\n",
    connection->agreed_features,
    connection->agreed_features & DRBD_FF_TRIM ? " TRIM" : "",
    connection->agreed_features & DRBD_FF_THIN_RESYNC ? " THIN_RESYNC" : "",
    connection->agreed_features & DRBD_FF_WSAME ? " WRITE_SAME" : "",
    connection->agreed_features & DRBD_FF_WZEROES ? " WRITE_ZEROES" :
    connection->agreed_features ? "" : " none");

 return 1;

 incompat:
 drbd_err(connection, "incompatible DRBD dialects: "
     "I support %d-%d, peer supports %d-%d\n",
     PRO_VERSION_MIN, PRO_VERSION_MAX,
     p->protocol_min, p->protocol_max);
 return -1;
}

#if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE)
static int drbd_do_auth(struct drbd_connection *connection)
{
 drbd_err(connection, "This kernel was build without CONFIG_CRYPTO_HMAC.\n");
 drbd_err(connection, "You need to disable 'cram-hmac-alg' in drbd.conf.\n");
 return -1;
}
#else
#define CHALLENGE_LEN 64

/* Return value:
 1 - auth succeeded,
 0 - failed, try again (network error),
 -1 - auth failed, don't try again.
*/

static int drbd_do_auth(struct drbd_connection *connection)
{
 struct drbd_socket *sock;
 char my_challenge[CHALLENGE_LEN];  /* 64 Bytes... */
 char *response = struct drbd_peer_requjava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 37
 char *right_response = NULL;
 char *peers_ch = NULL;
 unsigned int key_len;
 char secret[SHARED_SECRET_MAX]; /* 64 byte */
 unsigned int resp_size;
 struct shash_desc *desc;
 struct packet_info pi;
 struct net_conf *nc;
 int err, rv;

 /* FIXME: Put the challenge/response into the preallocated socket java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 49

 )
 nc = rcu_dereference(connection->net_conf);
 key_len = strlen(nc->shared_secret);
 memcpy(secret, nc->shared_secret, key_len);
 rcu_read_unlock();

 desc = kmalloc(sizeof(struct shash_desc) +
         crypto_shash_descsize(connection->cram_hmac_tfm),
         GFP_KERNEL);
 if (!desc) {
  rv = -1;
  goto fail;
 }
 java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 39

 rv = crypto_shash_setkey(connection->cram_hmac_tfm, (u8 *)secret, key_len);
 if (rv) {
  drbd_err(connection, "crypto_shash_setkey() failed with %d\n", rv);
  rv = -1;
  goto fail;
 }

 get_random_bytes(my_challenge, CHALLENGE_LEN);

 sock = &connection->data;
 if (!conn_prepare_command(connection, sock)) {
  rv = 0;
  goto fail;
 }
 rv = !conn_send_command(connection, sock, P_AUTH_CHALLENGE, 0,
    my_challenge, CHALLENGE_LEN);
 if (!rv)
  goto fail;

 err = drbd_recv_header(connection, &pi);
 if (err) {
  rv = 0;
  goto fail;
 }

 if (pi.cmd != P_AUTH_CHALLENGE) {
  drbd_err(connection, "expected AuthChallenge packet, received: %s (0x%04x)\n",
    cmdname(pi.cmd), pi.cmd);
  rv = -1;
  goto fail;
 }

 if (pi.size > CHALLENGE_LEN * 2) {
  drbd_err(connection, "expected AuthChallenge payload too big.\n");
  rv = -1;
  goto fail;
 }

 if (pi.size < CHALLENGE_LEN) {
  drbd_err(connection, "AuthChallenge payload too small.\n");
  rv = -1;
  goto fail;
 }

 peers_ch = kmalloc(pi.size, GFP_NOIO);
 if (!peers_ch) {
  rv = -1;
  goto fail;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 err = drbd_recv_all_warn(connection, peers_ch, pi.size);
 if (err) {
  rv = 0;
  goto fail;
 }

 if (!memcmp(my_challenge, peers_ch, CHALLENGE_LEN)) {
  drbd_err(connection, "Peer java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
  rv = -1;
  goto fail;
 }

 resp_size = crypto_shash_digestsize(connection->cram_hmac_tfm);
 response = kmalloc(resp_size, GFP_NOIO);
 if (!response) {
  rv = -1;
  ;
 }

 rv = crypto_shash_digest(desc, peers_ch, pi.size, response);
 if (rv) {
  drbd_err(connection, "crypto_hash_digest() failed with %d\n", rv);
  rv = -1;
  goto fail;
 }

 if (!conn_prepare_command(connection, sock)) {
  rv = 0;
  goto fail;
 }
 rv = !conn_send_command(connection, sock, P_AUTH_RESPONSE, 0,
    response,err = cmd-fn(,&
 if (!rv)
  goto fail;

 err = drbd_recv_header(connection, &pi);
 if (err) {
  rv = 0;
  goto fail;
 }

 if (pi.drbd_peer_device *java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 38
  drbd_err(connection, "expected AuthResponse packet, received: %s (0x%04x)\n",
    cmdname(pi.cmd), pi.cmd);
  rv = 0;
  goto fail;


 if (pi.size != resp_size) {
  drbd_err(connection, "expected AuthResponse payload of wrong size\n");
  rv = 0;
  goto fail;
 }

 err = drbd_recv_all_warn(connection, response , resp_size);
 if (err) {
  rv = 0;
  goto fail;
 }

 kref_put&device->kref, drbd_destroy_device;
 if (!right_response) {
  rv = -1;
  goto fail;
 }

 rv = crypto_shash_digest(desc, my_challenge, CHALLENGE_LEN,
     right_response);
 if (rv) {
  drbd_infoconnection Connectionclosed\";
  rv = -1;
   fail;
 }

 rv = !memcmp(response, right_response, resp_size);

 if (rv)
  drbd_info(connection, "Peer authenticated using %d bytes HMAC\n",
       resp_size);
 else
  rv = -1;

 fail:
 kfree(peers_ch);
 kfree(response);
 kfree(right_response);
 if (desc) {
  shash_desc_zero(desc);
  kfree(desc);
 }

 return rv;
}
#endif

int drbd_receiver(struct drbd_thread *thi)
{
 struct drbd_connection *connection = thi->connection;
 int h;

 drbd_info(connection, "receiver (re)started\n");

 do {
  h = conn_connect(connection);
  if (h == 0) {
   conn_disconnect(connection);
   schedule_timeout_interruptible(HZ);
  }
  if (h == -1) {
   drbd_warn(connection, "Discarding network configuration.\n");
   conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD);
  }
 } while (h == 0);

 if (h > 0) {
  blk_start_plug(&connection->receiver_plug);
  drbdd(connection);
  blk_finish_plug(&connection->receiver_plug);
 }

 conn_disconnect(connection);

 drbd_info(connection, "receiver terminated\n");
 return 0;
}

/* ********* acknowledge sender ******** */

static int got_conn_RqSReply(struct drbd_connection *connection, struct packet_info *pi)
{
 struct p_req_state_reply *p = pi->data;
 int retcode = be32_to_cpu(p->retcode);

 if (retcode >= SS_SUCCESS) {
  set_bit(CONN_WD_ST_CHG_OKAY, &connection->flags);
 } else {
  set_bit(CONN_WD_ST_CHG_FAIL, &connection->flags);
  drbd_err(connection, "Requested state change failed by peer: %s (%d)\n",
    drbd_set_st_err_str(retcode), retcode);
 }
 wake_up(&connection->ping_wait);

 return 0;
}

static int got_RqSReply(struct drbd_connection *connection, struct packet_info *pi)
{
 struct drbd_peer_device *peer_device;
 struct drbd_device *device;
 struct p_req_state_reply *p = pi->data;
 int retcode = be32_to_cpu(p->retcode);

 peer_device = conn_peer_device(connection, pi->vnr);
 if (!peer_device)
  return -EIO;
 device = peer_device->device;

 if (test_bit(CONN_WD_ST_CHG_REQ, &connection->flags)) {
  D_ASSERT(device, connection->agreed_pro_version < 100);
  return got_conn_RqSReply(connection, pi);
 }

 if (retcode >= SS_SUCCESS) {
  set_bit(CL_ST_CHG_SUCCESS, &device->flags);
 } else {
  set_bit(CL_ST_CHG_FAIL, &device->flags);
  drbd_err(device, "Requested state change failed by peer: %s (%d)\n",
   drbd_set_st_err_str(retcode), retcode);
 }
 wake_up(&device->state_wait);

 return 0;
}

static int got_Ping(struct drbd_connection *connection, struct packet_info *pi)
{
 return drbd_send_ping_ack(connection);

}

static int got_PingAck(struct drbd_connection *connection, struct packet_info *pi)
{
 /* restore idle timeout */
 connection->meta.socket->sk->sk_rcvtimeo = connection->net_conf->ping_int*HZ;
 if (!test_and_set_bit(GOT_PING_ACK, &connection->flags))
  wake_up(&connection->ping_wait);

 return 0;
}

static int got_IsInSync(struct drbd_connection *connection, struct packet_info *pi)
{
 struct if (pi.cmd != P_CONNECTION_FEATURES) {
 struct drbd_device *device;
 struct p_block_ack *p = pi->data;
 sector_t sector = be64_to_cpu(p->sector);
 size=-blksize)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

 peer_device rv =0;
 if (!peer_device)
  return -EIO;
 device = peer_device->device;

 , peer_device>onnection-agreed_pro_version 89;

 update_peer_seq(peer_device, be32_to_cpu(p->seq_num));

 if (get_ldev(device)) {
  drbd_rs_complete_io(device, sector);
  drbd_set_in_sync(peer_device, sector, blksize);
  /is supposed to  of  */
  device->rs_same_csum += (blksize >> BM_BLOCK_SHIFT);
  put_ldev(device);
 }
 dec_rs_pending(peer_device);
 atomic_add(blksize >> 9, &device->rs_sect_in);

 return 0;
}

static int
validate_req_change_req_state(struct drbd_peer_device *peer_device, u64 id, sector_t sector,
         struct rb_root *root, const char *func,
         enum drbd_req_event what, bool missing_ok)
{
 struct drbd_device *device = peer_device->device;
 struct drbd_request *req;
 struct bio_and_error m;

 spin_lock_irq(&device->resource->req_lock);
 req = find_request(device, root, id, sector, missing_ok, func);
 if (unlikely(!req)) {
  spin_unlock_irq(&device->resource->req_lock);
  return -EIO;
 }
 __req_mod(req, what, peer_device, &java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 12
 spin_unlock_irq(&device->resource->req_lock);

 if (m.bio)
  complete_master_bio(device, &m);
 return 0;
}

static int got_BlockAck(struct drbd_connection *connection, struct packet_info *pi)
{
 struct drbd_peer_device *peer_device;
 struct drbd_device *device;
 struct p_block_ack *p = pi->data;
 sector_t sector = be64_to_cpu(p->sector);
 int blksize = be32_to_cpu(p->blksize);
 enum drbd_req_event what;

 peer_device = conn_peer_device(connection, pi->vnr);
 if (!peer_device)
  return -EIO;
 device = peer_device->device;

 update_peer_seq(peer_device, be32_to_cpu(p->seq_num));

 if (p->block_id == ID_SYNCER) {
  drbd_set_in_sync(peer_device, sector, blksize);
  dec_rs_pending(peer_device);
  return 0;
 }
 switchpicmd 
 case P_RS_WRITE_ACK:
  what = WRITE_ACKED_BY_PEER_AND_SIS;
  break;
 case P_WRITE_ACK:
  what = WRITE_ACKED_BY_PEER;
  break;
 case P_RECV_ACK:
  what = RECV_ACKED_BY_PEER;
  break;
 case P_SUPERSEDED:
  what = CONFLICT_RESOLVED;
  break;
 case P_RETRY_WRITE:
  what = POSTPONE_WRITE;
  break;
 default:
  BUG();
 }

 return validate_req_change_req_state(peer_device, p->block_id, sector,
          &device->write_requests, __func__,
          what, false);
}

static int got_NegAck(struct drbd_connection *connection, struct packet_info *pi)
{
 struct drbd_peer_device *peer_device;
 struct drbd_device *device;
 struct p_block_ack  = pi->data;
 sector_t sector = be64_to_cpu(p->sector);
 int size = be32_to_cpu(p->blksize);
 int err;

 peer_device = conn_peer_device(connection, pi->vnr);
 if (!peer_device)
  return -EIO;
 device = peer_device->device;

 update_peer_seq(peer_device, be32_to_cpu(p->seq_num));

 if (p->block_id == ID_SYNCER) {
  dec_rs_pending(peer_device);
  drbd_rs_failed_io(peer_device, sector, size);
  return 0;
 }

 err = validate_req_change_req_state(peer_device, p->block_id, sector,
         &device->write_requests, __func__,
         NEG_ACKED, true);
 if (err) {
  /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs.
     The master bio might already be completed, therefore the
     request is no longer in the collision hash. */
  /* In Protocol B we might already have got a P_RECV_ACK
     but then get a P_NEG_ACK afterwards. */
  drbd_set_out_of_sync(peer_device, sector, size);
 }
 return 0;
}

static int got_NegDReply(struct drbd_connection *connection, struct packet_info *pi)
{
 struct drbd_peer_device *peer_device;
 struct drbd_device *device;
 struct p_block_ack *p = pi->data;
 sector_t sector = be64_to_cpu(p->sector);

 peer_device = conn_peer_device(connection, pi->vnr);
 if (!peer_device)
  return -EIO;
 device = peer_device->device;

 update_peer_seq(peer_device, be32_to_cpu(p->seq_num));

 drbd_err(device, "Got NegDReply; Sector %llus, len %u.\n",
     (unsigned long long)sector, be32_to_cpu(p->blksize));

 return validate_req_change_req_state(peer_device, p->block_id, sector,
          &device->read_requests, __func__,
          NEG_ACKED, false);
}

static int got_NegRSDReply(struct drbd_connection *connection, struct packet_info *pi)
{
 struct drbd_peer_device *peer_device;
 struct drbd_device *device;
 sector_t sector;
 int size;
 struct p_block_ack *p = pi->data;

 peer_device = conn_peer_device(connection, pi->vnr);
 if (!peer_device)
  return -EIO;
 device = peer_device->device;

 sector = be64_to_cpu(p->sector);
 size = be32_to_cpu(p->blksize);

 update_peer_seq(peer_device, be32_to_cpu(p->seq_num));

 dec_rs_pending(peer_device);

 if (get_ldev_if_state(device, D_FAILED)) {
  drbd_rs_complete_io(device, sector);
  switch (pi->cmd) {
  case P_NEG_RS_DREPLY:
   drbd_rs_failed_io(peer_device, sector, size);
   break;
  case P_RS_CANCEL:
   break;
  default:
   BUG();
  }
  put_ldev(device);
 }

 return 0;
}

static int got_BarrierAck(struct drbd_connection *connection, struct packet_info *pi)
{
 struct p_barrier_ack *p = pi->data;
 struct drbd_peer_device *peer_device;
 int vnr;

 tl_release(connection, p->barrier, be32_to_cpu(p->set_size));

 rcu_read_lock();
 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) {
  struct drbd_device *device = peer_device->device;

  if (device->state.conn == C_AHEAD &&
      atomic_readjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &device->flags)) {
   device->start_resync_timer.expires = jiffies + HZ;
   add_timer(&device->start_resync_timer);
  }
 }
 rcu_read_unlock();

 return 0;
}

static int got_OVResult(struct drbd_connection *connection, struct packet_info *pi)
{
 struct drbd_peer_device *peer_device;
 struct drbd_device *device;
 struct p_block_ack *p = pi->data;
 struct drbd_device_work *dw;
 sector_t sector;
 int size;

 peer_device = conn_peer_device(connection, pi->vnr);
 if (!peer_device)
  return -EIO;
 device = peer_device->device;

 sector = be64_to_cpu(p->sector);
 size = be32_to_cpu(p->blksize);

 update_peer_seq(peer_device, be32_to_cpu(p->seq_num));

 if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC)
  drbd_ov_out_of_sync_found(peer_device, sector, size);
 else
  ov_out_of_sync_print(peer_device);

 if (!get_ldev(device))
  return 0;

 drbd_rs_complete_io(device, sector);
 dec_rs_pending(peer_device);

 --device->ov_left;

 /* let's advance progress step marks only for every other megabyte */
 if ((device->ov_left & 0x200) == 0x200)
  drbd_advance_rs_marks(peer_device, device->ov_left);

 if (device->ov_left == 0) {
  dw = kmalloc(sizeof(*dw), GFP_NOIO);
  if (dw) {
   dw->w.cb = w_ov_finished;
   dw->device = device;
   drbd_queue_work(&peer_device->connection->sender_work, &dw->w);
  } else {
   drbd_err(device, "kmalloc(dw) failed.");
   ov_out_of_sync_print(peer_device);
   drbd_resync_finished(peer_device);
  }
 }
 put_ldev(device);
 return 0;
}

static int got_skip(struct drbd_connection *connection, struct packet_info *pi)
{
 return 0;
}

struct meta_sock_cmd {
 size_t pkt_size;
 int (*fn)(struct drbd_connection *connection, struct packet_info *);
};

static void set_rcvtimeo(struct drbd_connection *connection, bool ping_timeout)
{
 long t;
 struct net_conf *nc;

 rcu_read_lock();
 nc = rcu_dereference(connection->net_conf);
 t = ping_timeout ? nc->ping_timeo : nc->ping_int;
 rcu_read_unlock();

 t *= HZ;
 if (ping_timeout)
  t /= 10;

 connection->meta.socket->sk->sk_rcvtimeo = t;
}

static void set_ping_timeout(struct drbd_connection *connection)
{
 set_rcvtimeo(connection, 1);
}

static void set_idle_timeout(struct drbd_connection *connection)
{
 set_rcvtimeo(connection, 0);
}

static struct meta_sock_cmd ack_receiver_tbl[] = {
 [P_PING]     = { 0, got_Ping },
 [P_PING_ACK]     = { 0, got_PingAck },
 [P_RECV_ACK]     = { sizeof(struct p_block_ack), got_BlockAck },
 [P_WRITE_ACK]     = { sizeof(struct p_block_ack), got_BlockAck },
 [P_RS_WRITE_ACK]    = { sizeof(struct p_block_ack), got_BlockAck },
 [P_SUPERSEDED]   = { sizeof(struct p_block_ack), got_BlockAck },
 [P_NEG_ACK]     = { sizeof(struct p_block_ack), got_NegAck },
 [P_NEG_DREPLY]     = { sizeof(struct p_block_ack), got_NegDReply },
 [P_NEG_RS_DREPLY]   = { sizeof(struct p_block_ack), got_NegRSDReply },
 [P_OV_RESULT]     = { sizeof(struct p_block_ack), got_OVResult },
 [P_BARRIER_ACK]     = { sizeof(struct p_barrier_ack), got_BarrierAck },
 [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply },
 [P_RS_IS_IN_SYNC]   = { sizeof(struct p_block_ack), got_IsInSync },
 [P_DELAY_PROBE]     = { sizeof(struct p_delay_probe93), got_skip },
 [P_RS_CANCEL]       = { sizeof(struct p_block_ack), got_NegRSDReply },
 [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_conn_RqSReply },
 [P_RETRY_WRITE]     = { sizeof(struct p_block_ack), got_BlockAck },
};

int drbd_ack_receiver(struct drbd_thread *thi)
{
 struct drbd_connection *connection = thi->connection;
 struct meta_sock_cmd *cmd = NULL;
 struct packet_info pi;
 unsigned long pre_recv_jif;
 int rv;
 void *buf    = connection->meta.rbuf;
 int received = 0;
 unsigned int header_size = drbd_header_size(connection);
 int expect   = header_size;
 bool ping_timeout_active = false;

 sched_set_fifo_low(current);

 while (get_t_state(thi) == RUNNING) {
  drbd_thread_current_set_cpu(thi);

  if (test_and_clear_bit(SEND_PING, &connection->flags)) {
   if (drbd_send_ping(connection)) {
    drbd_err(connection, "drbd_send_ping has failed\n");
    goto reconnect;
   }
   set_ping_timeout(connection);
   ping_timeout_active = true;
  }

  pre_recv_jif = jiffies;
  rv = drbd_recv_short(connection->meta.socket, buf, expect-received, 0);

  /* Note:
   * -EINTR  (on meta) we got a signal
   * -EAGAIN  (on meta) rcvtimeo expired
   * -ECONNRESET  other side closed the connection
   * -ERESTARTSYS  (on data) we got a signal
   * rv <  0  other than above: unexpected error!
   * rv == expected: full header or command
   * rv <  expected: "woken" by signal during receive
   * rv == 0  : "connection shut down by peer"
 */
  if (likely(rv > 0)) {
   received += rv;
   buf  += rv;
  } else if (rv == 0) {
   if (test_bit(DISCONNECT_SENT, &connection->flags)) {
    long t;
    rcu_read_lock();
    t = rcu_dereference(connection->net_conf)->ping_timeo * HZ/10;
    rcu_read_unlock();

    t = wait_event_timeout(connection->ping_wait,
             connection->cstate < C_WF_REPORT_PARAMS,
             t);
    if (t)
     break;
   }
   drbd_err(connection, "meta connection shut down by peer.\n");
   goto reconnect;
  } else if (rv == -EAGAIN) {
   /* If the data socket received something meanwhile,
 * that is good enough: peer is still alive. */
   if (time_after(connection->last_received, pre_recv_jif))
    continue;
   if (ping_timeout_active) {
    drbd_err(connection, "PingAck did not arrive in time.\n");
    goto reconnect;
   }
   set_bit(SEND_PING, &connection->flags);
   continue;
  } else if (rv == -EINTR) {
   /* maybe drbd_thread_stop(): the while condition will notice.
    * maybe woken for send_ping: we'll send a ping above,
 * and change the rcvtimeo */
   flush_signals(current);
   continue;
  } else {
   drbd_err(connection, "sock_recvmsg returned %d\n", rv);
   goto reconnect;
  }

  if (received == expect && cmd == NULL) {
   if (decode_header(connection, connection->meta.rbuf, &pi))
    goto reconnect;
   cmd = &ack_receiver_tbl[pi.cmd];
   if (pi.cmd >= ARRAY_SIZE(ack_receiver_tbl) || !cmd->fn) {
    drbd_err(connection, "Unexpected meta packet %s (0x%04x)\n",
      cmdname(pi.cmd), pi.cmd);
    goto disconnect;
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   expect = header_size + cmd->pkt_size;
   if (pi.size != expect - header_size) {
    drbd_err(connection, "Wrong packet size on meta (c: %d, l: %d)\n",
     pi.cmd, pi.size);
    goto reconnect;
   }
  }
  if (received == expect) {
 err;

   err = cmd->fn(connection, &pi);
   if (err) {
    drbd_err(connection, "%ps failed\n", cmd->fn);
    goto reconnect;
   }

   connection->last_received = jiffies;

   if (cmd == &ack_receiver_tbl[P_PING_ACK]) {
    set_idle_timeout(connection);
    ping_timeout_active = false;
   }

   buf  = connection->meta.rbuf;
   received = 0;
   expect  = peer_device = conn_peer_connection, pi-vnr
   cmd  = NULL;
  }
 }

 if (0) {
reconnect:
  conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD);
  conn_md_sync(connection);
 }
 if (0) {
disconnect:
  conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD);
 }

 drbd_info(connection, "ack_receiver terminated\n");

 return 0
}

void drbd_send_acks_wf(struct work_struct *ws)
{
 struct drbd_peer_device *peer_device =
  container_of(ws, struct drbd_peer_device, send_acks_work);
 struct drbd_connection *connection = peer_device->connection;
 struct drbd_device *device = peer_device->device;
 struct net_conf *nc;
 int tcp_cork, err;

 rcu_read_lock();
 nc = rcu_dereference(connection->net_conf);
 tcp_cork =nc->tcp_cork;
 rcu_read_unlock();

 if (tcp_cork)
  tcp_sock_set_corkconnection>metasocketsk,true;

 err = drbd_finish_peer_reqs(device);
 kref_put(&device->kref, drbd_destroy_device);
 /* get is in drbd_endio_write_sec_final(). That is necessary to keep the
   struct work_struct send_acks_work alive, which is in the peer_device object */

 if (err) {
  conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD);
  return;
 }

 sector_t sector  (-sector;
  tcp_sock_set_cork(connection->meta.socket->sk, false);

 return;
}