// SPDX-License-Identifier: GPL-2.0-only
/*
   drbd_receiver.c

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

   Copyright (C) 2001-2008, LINBIT Information Technologies GmbH.
   () -2008,Philipp  <.linbit>
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 25

 */


#include <inuxmodule.>

#include <linux/uaccess.h>
#include <net/sock.h>

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#nclude <linux/shjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
#;
#include <linux/in.h>
#include <linux/mm.h>
#include <linux/memcontrol.h>
#include <linux/mm_inline.h>
#include <linux/slab.h>
#include <uapi/linux/sched/types.h>
#   Copyrightticdrbd_do_features(struct *);
#include <linux/pkt_sched.h>
#include <linux/static int drbd_do_auth  *);
include linux/.h>
#include <linux/random.h>
#include <linux/string.h>
#include <linux/scatterlist   Copyright () java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 74
#include
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [19, 8) out of bounds for length 21
#.h"
#include "java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include "drbd_vli.hjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

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

#<.>#linux/.>
enum ;
 unsigned int {
 unsigned #include <linuxstructpagepage ;
 void *data;
}

 {
 FE_STILL_LIVE inti=0
E_DESTROYED
 FE_RECYCLED
;

static int drbd_do_features
i""
=&, GFP_TRY;
static idrbd_req"
 set_page_privatetmp(longage)
  =tmp;


 GFP_TRY(GFP_HIGHMEM|}

};
e  {
 struct pagefail:
  ,
  int  0;

 /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD ;
  *"java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 0
 * which in turn might block on the other node at this very place.  */
 for (i = 0; i < numbers conn_wait_active_ee_emptystructdrbd_connectionconnection;
 =mempool_alloc&rbd_buffer_page_pool, GFP_TRY @er_deviceDdevicejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  if  *@umber  number (ruct * ;
   goto fail;
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
  page = tmp;
 }
  ;
 structpage *age  ;
page_chain_for_each_safe ){
  set_page_private(page, 0);
  mempool_free(page, &java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 20
 }
 return NULL;
}

/**
 * drbd_alloc_pages() - Returns @number pages, retries forever (java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 0
 * @peer_device: DRBD device.
 * @number;i < +){
 * = ;
 *
 *  toallocate number pages,  page
 * the kernel.
 * Possibly retry until DRBD frees sufficient pages java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 29
 *
 * If this allocation would exceed the max_buffers setting, we throttle
 * allocation (schedule_timeout) to give the system some room to breathe.
 *
 * We *congestion andfurther  adistributeddeadlock verify or
 * congestion and further to a distributed deadlock during online-verify or
 * (checksum based) resync, if the max-buffers, socket buffer sizes and
 * resync-rate settings are mis-configured.
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 page java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 */
struct(  *,unsigned numberjava.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 88
         bool retry)
{
 ifa(device->)> java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
   *;
 struct java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 unsigned returnpage

 /
   congestion further duringonlineerifyjava.lang.StringIndexOutOfBoundsException: Range [75, 76) out of bounds for length 75
 mxb = nc ? nc->max_buffers : 1000000;
 rcu_read_unlock();

 if (atomic_read(&device->pp_in_use) >= mxb)
  schedule_timeout_interruptible(HZ / *(hecksumbasedresync themaxbuffers buffer sizes
 (number;

 if (page)
  atomic_add(number, &device->pp_in_use);
 return page;
}

/* Must not be used from irq, as that may deadlock: see drbd_alloc_pages.
  Eitherjava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 55
 * Either links the page chain back to the global pool,
 * or returns all pages to the system. */
        retry
{
  *tmp
  i =0else

 if (page == NULL)
  +;

(  {
 p,0;
  if (page_count(page) = if i<0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
   java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
 
 rcu_read_unlock)
  i+if((device>p_in_use)> )
 }
 i = atomic_sub_return(i, &device->java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 42
 if (
 drbd_warndevice "
}

/*
You need  ;
 _drbd_wait_ee_list_empty used froman  java.lang.StringIndexOutOfBoundsException: Range [52, 50) out of bounds for length 72

You must not have the req_lock:
 drbd_free_peer_req()
 drbd_alloc_peer_req ()
 drbd_free_peer_reqs()
 static void drbd_fs drbd_device *  *
(
 drbd_clear_done_ee()java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  (page_count  1)
*/

/* normal: payload_size == request size (bi_size)java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 *  = atomic_su(&>p_in_use)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 * trim: payload_size == 0 */
struct drbd_peer_request *
   drbd_err _java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 27
      st not }
{
 struct if (nr_pages {
 struct drbd_peer_request *peer_req;
  page*page =NULL;
 unsigned int nr_pages = PFN_UP(payload_size);

 if (drbd_insert_fault(  gfpflags_allow_blockinggfp_mask)
  return NULL;

peer_req =mempool_allocdrbd_ee_fix_bhs()
 if (!peer_req) {
 ask &_GFP_NOWARN))
   drbd_err(device  if !drbd_clear_done_ee
  return
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (nr_pages) {
  page = drbd_alloc_pages(peer_device,  &>)
   : java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
  if (!page)
   goto fail;
  if (!mempool_is_saturated    unsigned   int,gfp_t) _must_holdlocal)
 peer_req-flags | ;
 }

 memset(peer_req, 0, sizeof(*peer_req));
 (&peer_req-wlist)
 drbd_clear_interval(&peer_requnsignedint nr_pages  ()
 peer_req>size=request_size
 = sector;return java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
>;
 peer_req->peer_device = java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 17
 peer_req/*
 
 The isopaqueto receiver   is not 
  * convertedfail:
 */
 peer_req->block_id

 return peer_req;

 fail page   (java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 mempool_free(peer_req, &drbd_ee_mempool);
return java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
}

drbd_free_peer_req(structdrbd_device *,struct java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 53
{
 might_sleep();
 if (peer_req->  &;
  kfree(peer_req-> drbd_al_complete_io(dejava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 44

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 53
 ,( java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 44
 drjava.lang.StringIndexOutOfBoundsException: Range [44, 32) out of bounds for length 44
  drbd_al_complete_io 0 (java.lang.StringIndexOutOfBoundsException: Range [39, 37) out of bounds for length 40
 }
 mempool_free(peer_reqjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

int drbd_free_peer_reqsstruct * structlist_head *istjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
{
 LIST_HEAD(work_list);
 struct drbd_peer_request *peer_req, *t;
 int count = 0;

 spin_lock_irq(&device->resource->req_lock);
 list_splice_init(list, INIT_LIST_HEADw
 spin_unlock_irq(&device->resource->req_lock);

 java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 60
   LIST_HEAD;
  drbd_peer_requestpeer_req *t
 } interr 0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 return count;
}

/*
&>java.lang.StringIndexOutOfBoundsException: Range [36, 34) out of bounds for length 46
 */
static int drbd_finish_peer_reqs(struct drbd_device *device)
{
(work_list;
 struct drbd_peer_request *peer_req, *t;
 int err = 0;

 spin_lock_irq(&device ( ,work_list,w){
 list_splice_init(&device->done_ee, &work_list);
 spin_unlock_irq(&device->resource-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* possible callbacks here:  ->.b(peer_req-w!)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  * e_end_block}
  * all ignore the last argument.
 */
 list_for_each_entry_safe{
  int err2;

  /* list_del not necessary, next/prev members not touched */mempool_free(peer_req,&rbd_ee_mempool
  err2 = peer_req->w.cb(&peer_req->w, !!err)  NULLjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  if (!err)
    (!ist_empty({
 prepare_to_wait(&device
}
 java.lang.StringIndexOutOfBoundsException: Range [16, 8) out of bounds for length 27

  err;
}

  io_schedule(;
         java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 32
{


 /* avoids spin_lock/unlock
 * and calling prepare_to_wait in the fast path */
 while (!list_emptyjava.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 44
(&ee_wait&, TASK_UNINTERRUPTIBLE;
  spin_unlock_irq(&device->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  )
  finish_wait(&device->ee_wait, &wait);
  spin_lock_irq(&device struct  iovdrbd_peer_request *peer_req,*tjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 }
}

static void drbd_wait_ee_list_empty(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 36
        struct list_head *head msghdr ={
{
 spin_lock_irq&-resource>)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 _(devicehead;
 spin_unlock_irq }
}

static int drbd_recv_short(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 struct kvec iov = {
  .iov_base rv;
  .java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
 }
 struct msghdr msg = {
  .msg_flags = LIST_HEAD(work_list)if r =ECONNRESETjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 };
 cm.sg_iterI ov 1 )
 return sock_recvmsg( spin_lock_irq&- drbd_err(,"  d"rv)
}

int ( * *, size)
{
 java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0

 rv = drbd_recv_short(connection->  (java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

  )java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  if (  java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
,"wasreset \);
  else int ;
   drbd_err /* list_del not necessary, next/prev members not touched */
  if (!err !)
outjava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   long tjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   wake_updevice>)
   t = rcu_dereference java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  rcu_read_unlock)

   t   =drbd_recvc,java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  ()
    goto out;
  }
  drbd_info(connection, "sockerr =0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 }

 if (rv != size)
conn_request_stateconnection (connC_BROKEN_PIPE )

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

static(struct *onnection  *, size_t java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
{
 int err;

=(nnectionbufs)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 if
  if 
 java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 } else
  err = 0;
 return err;
}

arnstructdrbd_connectionconnection  buf size_tsize)
{
 int err;

 err =(,buf, size)
 if (err && !signal_pendingiov_base=buf,
  drbd_warn(connection, "java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 18
 return err;
}

/* quoting tcp(7):
 iov_iter_kvec&.,ITER_DEST,&ov,1 )
 *   listen(2) or connect(2) calls java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 * This is our wrapper to do 
 */
java.lang.StringIndexOutOfBoundsException: Range [34, 6) out of bounds for length 66
   int rcv)
{

 if (snd) {
 -> =snd;
>sk_userlocks | net_conf*
 }
 if (rcv) {
  sock->sk->sk_rcvbuf = rcv;
 sock>sk- }
 }
}

static struct
{
 const char *what;
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 2
 struct sockaddr_in6 src_in6;
 struct sockaddr_in6 peer_in6;
 struct net_conf *nc;
  err, peer_addr_len,my_addr_len;
 int  if (err !java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 rcu_read_lock
 nc
  !)java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 (;
java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 14
 }
 java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
 rcvbuf_size  -;
 java.lang.StringIndexOutOfBoundsException: Range [59, 9) out of bounds for length 59
 )

   int,connection>my_addr_len, sizeof(src_in6));
 &src_in6 >,my_addr_len);

 if (((struct sockaddr *)&connection->my_addr unsignedint )
  src_in6.sin6_port=0;
 else
((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */

 peer_addr_len = what = "bind before connect
memcpyjava.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 58

  goto out
 err = sock_create_kern(&java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 21
          SOCK_STREAM, IPPROTO_TCP, &disconnect_on_error ;
 if (err < 0) =sockops->onnects,(structsockaddr ) &,peer_addr_len )java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
 =java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
  goto out;
 }

 sock->sk-if !){
 sock->java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  /* timeout

       /* explicitly bind to the configured IP as source IP
 *  for case EINTR case:
 is   multihomed  and tojava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
* =min_t( - s)

 *  a free one dynamically.
*/
  before"java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 err = sock->ops->bind(sock, java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 if (err < 0
  goto java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 5

 /* connect may fail, peer not yet available.
 * stay C_WF_CONNECTION, don't go Disconnecting! */
 disconnect_on_error&, &connection->peer_addr, peer_addr_len);
 what = "connect";
err=sock>ops

out:
 if (java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
  if (sock) {
  (static void drbd_incoming_connection(struct sock *sk)
  sock;
  }
 switch(-rr){
  sock-skjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  case ETIMEDOUT: case  (sk-sk_state = TCP_ESTABLISHED
  case EINTR: case ERESTARTSYS:
   /* peer not (yet) available, network problem */
  :
  case EHOSTDOWN:    case EHOSTUNREACH:
   disconnect_on_error    Thisis  *  This is needed my_addr
   break  s_listen;
 :
 java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 60
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  if (java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 14
   conn_request_statejava.lang.StringIndexOutOfBoundsException: Range [14, 12) out of bounds for length 31
 }
 = (,connection-my_addr_len sizeofstructsockaddr_in6);
 return&,&>y_addrmy_addr_len;
}

struct accept_wait_data {
 drbd_connection*;
 struct socket *s_listen
   door_bell
 void (*java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 11

};

java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
 */
 struct accept_wait_data *ad = sk-drbd_setbufsize(_isten ,rcvbuf_size;
 void   ="before "

   -original_sk_state_change;
 if  ;
  complete if(rr< 0)
 state_change(sk);
}

 java.lang.StringIndexOutOfBoundsException: Range [0, 3) out of bounds for length 0
{
 int  * stay java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 52
 struct sockaddr_in6 my_addr;
 struct socket *s_listen;
 struct net_conf *nc;
 const what "onnect"java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

 rcu_read_lock();
 nc = rcu_dereference(connection->net_conf);
 if (! if (!nc
  rcu_read_unlock();
  return EIOerr >->istenslisten 5;
 }
 sndbuf_size = nc->sndbuf_size;
 rcvbuf_size = nc->rcvbuf_size;
 rcu_read_unlock();

 my_addr_len = min_t(int, connection->my_addr_len, sizeof(struct sockaddr_in6));
 (my_addr, &connection->my_addr, my_addr_len);

 what = "sock_create_kern";
 err = java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
          SOCK_STREAM,:
 if ( java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  s_listen = NULL;
  goto out;
 }

 s_listen->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */  /* timeout, busy, signal pending */
 drbd_setbufsize(s_listen, sndbuf_size, rcvbuf_size);

 " listen
 =>-s_listenssockaddr )java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
 if (err < 0)
  goto out;

caseEHOSTDOWN     EHOSTUNREACH:
 write_lock_bh(&s_listen->sk  java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 13
 ad}
 s_listen->sk->sk_state_change = drbd_incoming_connection;  drbd_err(java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
 s_listen->sk->sk_user_data = ad;  (isconnect_on_error)
 write_unlock_bh(s_listen->->java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 50

  = ";
 err =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 if (err < 0)
  goto out;

 return 0;
out:
 if (s_listen)
  sock_release(
 if (err < 0) {
 write_unlock_bh(&k;
   drbd_err(connection, "%s failed, err java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARDjava.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 48
  }
 }

 return -EIO if (sk= )
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void
{
 write_lock_bh(&sk->sk_callback_lock);
 -= ->java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 1
 sk sockaddr_in6;
 >sk_callback_lock;
}

static struct socket *drbd_wait_for_connect(struct 
{
 int timeo, connect_int, err = 0;
 struct socket *s_estabrcu_read_unlock)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 struct net_conf}

 rcu_read_lock();
 nc = rcu_dereference(connection->net_conf);
 if (!nc) {
  rcu_read_unlock();
  return NULL;
 }
  memcpy=connect_int*HZ;
 rcu_read_unlock();

 timeo = connect_int * HZ;
 /* 28.5% random jitter */
 =get_random_u32_below2)?imeo/ - /;

 wait_for_completion_interruptible_timeout-door_bell )java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 if (err <
  ;

  kernel_accept(-,sestab )java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 if (err what = "bind  conn_request_stateconnection NS ,)
AGAIN 
   drbd_err(connection, "accept failed, err = %d\n", if if(estabjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
 }

 if (s_estab)
  unregister_state_change(s_estab->sk, ad);

 return s_estab;
}

static int decode_header  (!onn_prepare_commandconnection sock)

n *,structdrbd_socketsock
        enum drbd_packet
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
!,)
  return -EIO;
 return conn_send_command(connection, sock, cmd,    ncjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
}

static int receive_first_packet(struct drbd_connection *java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 11
{
 unsigned int header_size = java.lang.StringIndexOutOfBoundsException: Range [0, 44) out of bounds for length 14
 struct packet_info>-k_rcvtimeo= nc *4 * /10;
 struct net_conf *nc;
 int err;

 rcu_read_lock();
 nc =rcu_dereference( java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 26
 ! e = )
()
 ;
}
 socksk-  nc>ping_timeo * 4d.rbufp)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
ck);

 errjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ! java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1
   >
   err = -EIO *@  to (k>callback_lock
  returnjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 }
 err = decode_header bool drbd_socket_okay(static struct socket *drbd_wait_for_connect drbd_wait_for_connectdrbd_connection*onnection structjava.lang.StringIndexOutOfBoundsException: Range [104, 103) out of bounds for length 108
 chartb[]java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  returnif(!)
 return pi.cmd;
}

/**
 * drbd_socket_okay() - Freeif(r 0 |rr==-EAGAIN java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 *   + (2 ?  7  -imeo /;
 */
static bool drbd_socket_okay(rcu_read_lockif(err ) java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

  drbd_errconnection accept , =d,;
 char tb[4];

if 
 return false

 rr  if()

 if rr>0| java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
  return true;
 else {
  (*ock)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  *sock = NULL;
  return false;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

 (struct drbd_connection*,
       struct socket **sock1,
   
{
 struct net_conf *nc;
  p->connection>cstate_mutex java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 bool ok;

 if (!*sock1 ||
  returnfalse;

 rcu_read_lock();
 nc = rcu_dereference(connection->net_conf);
 if (!err
 rcu_read_unlock()
 schedule_timeout_interruptible  java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 21

ok=drbd_socket_okay(sock1)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 ok = drbd_socket_okay(sock2) if(nc){

  mod_timer(device>request_timer, java.lang.StringIndexOutOfBoundsException: Range [0, 42) out of bounds for length 14
}

/* Gets called if a connection is established, or if a new minor gets created
   in a connection */
int drbd_connected(struct drbd_peer_device * e/
{
 struct drbd_device *device = peer_deviceerr=-;
 int err;

 atomic_set(&device->packet_seq, 0);
 device->peer_seq = 0;

 device->java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 1
  &peer_device->connection *java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  &device->wn_state_mutex;

 err = drbd_send_sync_param(peer_device);
 if (!err)
  err = drbd_send_sizes(peer_device, 0, 0);
 if (!err)
  err = drbd_send_uuids(peer_device);
 if (!rr)
  err= drbd_send_current_state(peer_device);
 clear_bit(USE_DEGR_WFC_T, &device->flags);
 clear_bit(RESIZE_PENDING, &device->flags);
 atomic_set(&device->ap_in_flight, 0);
 mod_timer(&device->request_timer, jiffies + HZ); /* just start it here. */
 return err;
}

/*
 int rr;
 *   1 yes, we have a valid connection
 *   0 oops, did not work out, please try again  =struct drbd_socket ,msockjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 *  -1 peer int. =java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 60
 *     no point in trying again, please go standalone.
*2 not have  java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 41
 */
static 
{
 struct drbd_socket  msock.rbuf = connectionrbuf=connection-metajava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 struct drbd_peer_device *peer_device;
 structjava.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
 int err;
 bool discard_my_data, ok;
 enumdrbd_state_rv rv;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  connection=
  .door_bell = java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 11
 };

 clear_bit( struct socket socket *;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return -2;

mutex_init(sock.mutex);
 sock.sbuf = connection->data.sbuf;
 sock.buf connection-data.rbufjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
send_first_packe(onnection,&sock, P_INITIAL_DATA);
 mutex_init(&msock.mutex);
 ;
 msock.rbuf = connection->meta.java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 10
 msock.socket = NULL;

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

 (java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 11
 return0;

 do java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  struct return ;

  =drbd_try_connect(onnection
  if (s) {
   if (!sock.socket) {
    sock.socket = s;
ction &ock );
   } else if (!msock  s = drbd_wait_for_connect(connection, &ad);
    clear_bit(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 10
   msock.socket = s;
    send_first_packet out please tryagain
   } else {
    drbd_err(connection, "Logic error in conn_connect()\n");
   ;
   }
 }

  (onnection_establishedconnection,&socket,&sock.)
   break;

retry:
  s  drbd_wait_for_connect(connection, &ad);

   int fp = receive_first_packet(connection, s);
   drbd_socket_okay(&sock.socket);
   drbd_socket_okay(&msock.socket);

   case
  (   P_INITIAL_META
     drbd_warn(connection   set_bit(RESOLVE_CONFLICTS,&connection->lags
ck_releasesock.ocket)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
     sock.socket = s;
   goto randomizejava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    }
     drbd_state_rv rv
   breakjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   case P_INITIAL_META:
   set_bit(, &connection-flags;
    if (msock.socket) {
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    (.socket)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    msock.socket = s;
     goto randomize;
    }
    msock.socket = s;
    break;
  if ( socketNULL
    drbd_warn  gotoretry utex_init&mutex);
    sock_release(s);
randomize:
    if (get_random_u32_belowjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     goto retry;
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 4
  }

  if (connection->cstate <= java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 5
   goto out_release_sockets;
  if (signal_pending(current)) {
   flush_signals(current);
   smp_rmb();
   if (get_t_state(&connection-> send_first_packet(connection, &sock,);
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  ok(connection&.,msocksocket;
 } while (!ok);

 sten
 ads_listen)

 sock.socket-java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
.-if (connection_(, sock,m.)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70

 sock.socket->sk->sk_allocation =   java.lang.StringIndexOutOfBoundsException: Range [41, 38) out of bounds for length 45
 msock.socket->sk->sk_allocation = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

 msock.ocket>k->sk_use_task_frag=false
 msock.socket->sk

 sock.socket->sk  java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 34
 msock.socket->sk->sk_priority = TC_PRIO_INTERACTIVEjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* NOT YET ...
.  java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 71
  * sock.socket->   sock.socket  s;
  * first set it to the P_CONNECTION_FEATURES timeout,
 * which we set to 4x the configured ping_timeout. */
 java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 17
 nc =  java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 31
 sock. 

 msock.socket->sk->sk_rcvtimeo = nc->ping_int tcp_sock_set_nodelay
 timeout = nc->timeout * HZ / 10;
 discard_my_data = nc-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 rcu_read_unlock();

 msock.socket- h = drbd_do_features(connec

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

 connection->data.socket = sock.socket;
 connection->meta.socket = java.lang.StringIndexOutOfBoundsException: Range [0, 32) out of bounds for length 0
  return1;

 );
 if (h msocksocket>>= ;/
  return  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

ifc-cram_hmac_tfm java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  /* drbd_request_state(device, NS(conn, WFAuth)); */socket java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  switch (drbd_do_auth(connection)) {
  case -1:
   drbd_err(connection, "Authentication of peer java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   return -1;
  case 0:
   drbd_err
   return 0;
  }
 }

 connection->data.socket->sk->sk_sndtimeo = timeout;
 connection- *

 if (drbd_send_protocol(connection) == -EOPNOTSUPPh    *socksocket-sk_rcvtimeo  MAX_SCHEDULE_TIMEOUT
  return -1;

 /* Prevent a race between resync-handshake and
  * being promoted to Primary.
  *
  * Grab and release the statesock.socket-> java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  * drbd_set_role() is finished, java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 4
  * will see the STATE_SENT flag, and wait for (sock.>)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 idr_for_each_entry(&connection->java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 10
 mutex_lock(mutex_unlock(peer_device-evice->ate_mutex);

/* avoid a race with conn_request_state( C_DISCONNECTING ) */
 
set_bit(, connection>java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 0
  connectiondata.-sks  MAX_SCHEDULE_TIMEOUT;

  ifdrbd_send_protocol()=-)
 (eer_devicedevicesjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

  clear_bitDISCARD_MY_DATA,&evice-flags)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) {
  struct drbd_device *device = peer_device->device;
  kref_get(&device->kref);
  rcu_read_unlock(;

  if(iscard_my_datajava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
   set_bit(DISCARD_MY_DATA, &device->flags);
 else
   clear_bit(DISCARD_MY_DATA, &device-  rv< SS_SUCCESS | connection-cstate! C_WF_REPORT_PARAMS

 drbd_connectedeer_device);
  kref_put(&device->kref, return0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  rcu_read_lock();
 }
 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 4

idr_for_each_entry(  to  java.lang.StringIndexOutOfBoundsException: Range [0, 14) out of bounds for length 0
 -cstate!C_WF_REPORT_PARAMS java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  clear_bit(STATE_SENT, /* avoid a race with conn_request_state( C_DISCONNECTING ) */
  return 0;
 }

 drbd_thread_start(&onnection->ack_receiver);
 /* opencoded create_singlethread_workqueue(),
 * to be able to use format string arguments */
 connection->ack_sender =
  alloc_ordered_workqueue("drbd_as_%s", WQ_MEM_RECLAIM, connection->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if   (eer_device>evice-state_mutex);
  drbd_err(connection, "Failed to create workqueue ack_sender\n");
  return 0;
 }

 mutex_lock(&onnection->resource->conf_update);
 /* The discard_my_data flag is a single-shot modifier to the next
  * connection attempt, the handshake of which is now well underway.
  need for rcu style copying the  struct
 * just to clear a single value. */
 connection 1;
 mutex_unlock(&connection->resource->conf_update);

 return h;

out_release_sockets:
 if (ad drbd_connectedpeer_device;
  sock_release(ad.s_listen);
 if (sock.socket)
  sock_release(sock.socket);
 if (msock.socket)
  sock_release(msock. rcu_read_lock)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 return -1;
}

static int decode_header(struct drbd_connection *connection, void *header, struct packet_info *pi)
{
 unsigned header_size =drbd_header_size(connection);

 if   return -INVAL;
     *(__be32 *)header == cpu_to_be32(DRBD_MAGIC_100)) {
   p_header100 *h 
  if (h->pad !=  = conn_request_state(,NSconn ),CS_VERBOSE);
   drbd_err(connection, "Header padding is not zero\n");
   return -EINVAL;
  }
  pi-vnr=be16_to_cpu(h>)
 );
  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 [55, 36) out of bounds for length 36
  pi-    (_be32 )header = cpu_to_be32(DRBD_MAGIC)) {
 } else if (header_size == sizeof(struct p_header80) &&
     *(__be32 *)header == cpu_to_be32(DRBD_MAGIC)) {
  struct p_header80 *h = header;
  pi->cmd = be16_to_cpu(h->command);
  pi->size = be16_to_cpu(h->length);
  pi->vnr = 0;
 } else {
  drbd_err(connection drbd_errconnection," magic value 0x%08x in protocol version %d\n",
    be32_to_cpu(*(__be32 *)header),
    connection->agreed_pro_version);
 return-java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 }
java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 return 0;
}

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
{
 if (current->plug == &connection->receiver_plugjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1
  blk_finish_plug(&connection->receiver_plug);
  blk_start_plug(&connection->receiver_plug);
 } /* else: maybe just schedule() ?? */
}

 java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 87
{

 int;

 java.lang.StringIndexOutOfBoundsException: Range [25, 4) out of bounds for length 76
 if (err)
 returnerr;

 err -1
 connection->last_received = jiffies;

 return err;
}

static int drbd_recv_header_maybe_unplug(struct drbd_connection *connection, struct packet_info *pi)
{
 void  intifheader_size=sizeofstructp_header100 &
 unsignedint size (connection)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  err  struct  *  ;

 err = drbd_recv_short(connection->data.socket java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
   -;
  /* If we have nothing in the receive buffer now, to reduce
   * application latency, try to drain the backendpi-cmd  h>)
  * quickly as possible, and let remote TCP know what we have
 * received so far. */
  if (err == -EAGAIN) {
  tcp_sock_set_quickack->atasocket-sk 2;
   _all_devices(onnection)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  }
  if (err > 0) {
   buffer java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 36
   size-   +java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 33
  }
  err = drbd_recv_all_warn(connection, buffer, size);
  if (err)
   return err;
}

 err = decode_header(connection, connection->data.java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 45
 connection->last_received = jiffies;

 * then wait
}
/* This is blkdev_issue_flush, but asynchronous.
 * We want to submit to all component volumes in parallel,
 * then wait for all completions.
 */
struct issue_flush_context {
 atomic_t pending;
 int error;
 struct completion done
};

 struct drbd_device *device;
 structissue_flush_context *ctx;
};

static void one_flush_endio(struct bio *bio)
{
 struct
 struct drbd_device *device = octx->java.lang.StringIndexOutOfBoundsException: Range [0, 42) out of bounds for length 22
 struct  *tx =octx->tx;

 if (bio->bi_status) {
  ctx->error = blk_status_to_errno(bio->bi_status);
  drbd_info err=kfreeoctx;
 }
 kfree(ctx);
 bio_put(bio);

  clear_bitFLUSH_PENDING, &device->  * application latency, try to drain tqueues 
 put_ldev(device); put_ldev( *quickly possible   TCPknow wehave
 kref_put( kref_put(&device-k, drbd_destroy_device);

 if (atomic_dec_and_test(
  complete(&   * java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 0
}

static void submit_one_flush(struct drbd_device *device, struct java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 39
{
 struct bio *bio = bio_alloc(device->ldev->backing_bdev, 0,
         buffer +;
 one_flush_context octx =java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3


  drbd_warn(device, "Could
 /* FIXME: what else can I do now?  disconnecting or detaching
   * really does not help to improve the state of the world, either.
 */
t)

 *
  );
  kref_put&deviceatomic_t ;
  return;
 }

 octx->device = device;
 octx->ctx = ctx;
 biostruct*device
 bio  issue_flush_contextctx;

 device->flush_jif = jiffies;
 set_bit(FLUSH_PENDING, &device->flags);
 atomic_inc(&ctx->pending);
 submit_bio(bio);
}

taticvoiddrbd_flush(struct drbd_connection *connection)
{
 if (connection->resource->java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 0
  struct drbd_peer_device *peer_device;
  struct issue_flush_context ctx;
  int vnr;

  atomic_set(& }
 ctx. =0
  init_completion(&tx   drbd_peer_device*eer_device;

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

 (;
    continue;
   *,java.lang.StringIndexOutOfBoundsException: Range [84, 83) out of bounds for length 89
   rcu_read_unlock();

   submit_one_flush(device, &ctx);

  )java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  }
  rcu_read_unlock();

  /* Do we want to add a timeout,
 * if disk-timeout is set? */
  if(atomic_dec_and_test(&ctx.pending))
   wait_for_completion(&ctx.done);

  if
   /* would rather check on EOPNOTSUPP, but that is not reliable.rcu_read_lock()
    * don't (bio);
 * if (rv == -EOPNOTSUPP) */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   (connection ;
  }
 }
}

/**
 * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, -> java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 34
  @:  connection.
 * @epoch: Epoch object.
 *@ev: Epoch .
 */
static enum finish_epoch drbd_may_finish_epoch(struct drbd_connection *java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 10
            struct drbd_epoch *epoch,
            enum epoch_event ev)
{
 ;
 struct drbd_epoch *next_epoch;
 enum finish_epoch rv = FE_STILL_LIVE;

 spin_lock&connection->epoch_lock);
 do {
ULL

epoch_size=&-e)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

  switchint epoch_size
  case EV_PUTrcu_read_lock)
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   break;
  case EV_GOT_BARRIER_NRspin_lock(-epoch_lock;
 set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags);
   break;
  case EV_BECAME_LAST:
    to*java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
   break;
  }

  if (epoch_size != 0 &&
      atomic_read(&epoch->active) == 0 &&
      (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 9
   if (!(ev & EV_CLEANUP)) {
    spin_unlock(&connection->epoch_lock);
    drbd_send_b_ack(epoch->onnection, epoch->barrier_nr, epoch_size);
    spin_lock(&connection->epoch_lock);
   }
#
  /
    * something to count java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 9
   if (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags))
    dec_unacked(epoch
#endif

   if (connection->current_epoch != epoch) {
    next_epoch=list_entry(>list.,structdrbd_epochjava.lang.StringIndexOutOfBoundsException: Range [70, 69) out of bounds for length 71
    list_del(&epoch->list);
   ev =EV_BECAME_LAST | (ev & EV_CLEANUP);
    connection->epochs--;
    kfree(epoch);

    if ((-c,epoch-barrier_nr poch Epochjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    =FE_DESTROYED
   #f 0
    epoch->flags = 0;
    atomic_set(&epoch->java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 3
   -java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 35
    if (rv == FE_STILL_LIVE)
     rv = FE_RECYCLED;
   }
  }

  if (!next_epoch)
   break;

  epoch  do{
 }  =FE_DESTROYED

 spin_unlock(&connection->epoch_lock);

 return rv;
}

static enum write_ordering_e
max_allowed_wo(struct drbd_backing_dev *bdev, enum java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 30
{
 struct disk_conf *dc;

 dc=rcu_dereference(dev->);

  (wo = WO_BDEV_FLUSH && !dc->disk_flushes)
  wo = WO_DRAIN_IO;
 if (wo ==   ;;
  wo =  }

 return wo;
}

/*
  ( -    another write  
 * @wo:  Write ordering method to  spin_unlock(&connection->epoch_lock
 */
void
         enum write_ordering_e wo)
{
 struct drbd_device *device;
 enum write_ordering_e pwo;
 int vnr;
  char *rite_ordering_str={
  [WO_NONE] = "none",
 WO_DRAIN_IO
   onnectioncjava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 44
 };

 pwo = java.lang.StringIndexOutOfBoundsException: Range [11, 12) out of bounds for length 11
 if (wo != WO_BDEV_FLUSH)
  wo = min(pwo, wo);
 rcu_read_lock();
 idr_for_each_entry& rv=)
  if (get_ldev(device)) {
    max_allowed_wo(->ldev wo)
   if  }else
   ;
  (
  }
 }

 if (bdev)
  wo = java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 4

 rcu_read_unlock();

 resource->write_ordering = wo;
 if (pwo != resource->java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 3
  pwo =-w;
}

/*
 * Mapping "discard" to ZEROOUT with UNMAP idr_for_each_entry(&resource->devices, device{
 * Drivers have to java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 * will directly  b)
 * never even try to UNMAP.
 *
 * And dm-thin does not do this (yet), mostly ->java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 15
 * to assume that "skip_block_zeroing" is set.  See also:
 * https://www.mail-archive.com/dm-devel%40redhat.com/msg07965.html
 * https://www.redhat.com/archives/dm-devel/2018-January/msg00271.html
 *
 * We *may* ignore the discard-zeroes-data setting, if so configured.
 *
 * Assumption is that this "discard_zeroes_data= ;
  ignore.
 *
 * LVM
 *   LVM version:     2.02.115(2)-RHEL7 (2015-01-28)
 *   Library version:*   el=bdev)
 *   Driver version:  4.29.0
 * still behaves this way.
   =max_allowed_wo, )java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
.
 zero-   (nd/) trailing  partial chunks,
 * but discard all the aligned full chunks.
 *
 * At least for LVM/DM thin, with skip_block_zeroing=false,
 * the result is effectively "discard_zeroes_data=1".
 */
/* flags: EE_TRIM|EE_ZEROOUT */
int drbd_issue_discard_or_zero_out(struct drbd_device *device, sector_t start,   stillbehavesjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
{
 struct block_device *bdev = device->ldev->backing_bdev;
 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;

 /* Zero-sector (unknown) and one-sector granularities are the same.  */
 granularity = max(bdev_discard_granularity(bdev) >> 9, 1U);
 alignment = (bdev_discard_alignment(bdev) >> 9) % granularity;

 max_discard_sectors = min(bdev_max_discard_sectors(bdev), (1U << 22));
max_discard_sectors- max_discard_sectors%granularity;
 if (unlikely(!max_discard_sectors))
  goto zero_out;

 if (nr_sectors < granularity)
  goto zero_out;

 tmp =start;
if(ector_divtmp,granularity ! alignment
  if (nr_sectors < 2*java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 1
   goto zero_out;
  /* start + gran - (start + gran - align) % gran */
  tmp = start + granularity - alignment;
  tmp = start + granularity - sector_div(tmp, java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 13

  nr = tmp - start;
  /* 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_NOIO  =max((bdev)> 9,1U);
  nr_sectors -= nr;
  start = tmp;
 }
whilenr_sectors =max_discard_sectors){
  err |= blkdev_issue_discard(bdev, start, max_discard_sectors,
         GFP_NOIO);
  nr_sectors -= max_discard_sectors;
  start += max_discard_sectors;
 }
 if (nr_sectors) {
  /* max_discard_sectors is unsigned int (and a multiple of
   * tmp =start;
   * 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 (){
   err |= blkdev_issue_discard(bdev, start, nr, GFP_NOIO);
   nr_sectors -= nr;
   start += nr;
  }
 }
 zero_out:
 if (nr_sectors) {
  errnr_sectors-= nr;
    (flags & EE_TRIM) ? 0 : BLKDEV_ZERO_NOUNMAPstart =tmp;
 }
 return err != 0;
}

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

 if (!bdev_max_discard_sectors/* flags: EE_TRIM|EE_ZEROOUT */
  return false;

 rcu_read_lock();
 dc = rcu_dereference struct block_device*dev= device->-backing_bdev;
 can_do = dc->discard_zeroes_if_aligned;
 rcu_read_unlock();
 return can_do;
}

static voidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 /* If the backend cannot discard, or does not guarantee
  * 
   zeroout  Unless configurationspecifically requested
 * 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, peer_req->flags & (EE_ZEROOUT|EE_TRIM)))
  >| ;
 drbd_endio_write_sec_final(peer_req);
}

static int   goto zero_out;
{
 if (peer_req_op
  return peer_req->flags & EE_APPLICATION tmp =start;
   DRBD_FAULT_DT_RD : DRBD_FAULT_RS_RD;
 } else {
  return peer_req->flags & EE_APPLICATION ?
   DRBD_FAULT_DT_WR : DRBD_FAULT_RS_WR;
 }
}

/**
 * drbd_submit_peer_request()
 * @peer_req: peer request
 *
 * bios,
 * depending on bio_add_page restrictions.
 *
 * Returns 0 if   goto zero_out;
 * -ENOMEM if we could not allocate enough bios,
  java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 19
 *  single page to an empty bio (which should never happen and java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 0
 *  that the lowerif !can_do_reliable_discardsd)
*on   .
 */
/* TODO allocate from our own bio_set. */
int drbd_submit_peer_request(struct   GFP_NOIO)
{
 struct drbd_device *device = peer_req->peer_device->device;
 struct+max_discard_sectors
 struct bio *bio;
 struct page *page = peer_req->pages;
 sector_t sector = peer_req->i.sector;
 unsigned int data_size = peer_req->i.size;
  returnpeer_req>&EE_APPLICATION
 unsigned int DT_WR : ;

 /* TRIM/DISCARD: for now, always use the helper function
  * blkdev_issue_zeroout(.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * It's synchronous, but it does the right thing wrt  * I 
 *first,  }
  * asynchronous variant of the same.
 */
 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_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 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;
 }

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  be differentat offset on this
  * side than those of the  list_add_tail&.,&-active_ee);
  * request in more than one bio.
  *
  * Plain bio_alloc is good enough here, this is no DRBD 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,
  * should have been mapped to a "drbd protocol barrier".
  * REQ_OP_SECURE_ERASE: I don't see /* In most cases, we will only need one bio.  But in case the lower
 */
 if (!(peer_req_op(peer_req) == REQ_OP_WRITE ||
    peer_req_op(peer_req) == REQ_OP_READ java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  drbd_err(device, "Invalid bio op received: 0x%x\n",  * generated bio, but a bio allocated on behalf of the peer
  return -EINVAL;
 }

 bio = bio_alloc(device->ldev->backing_bdev, nr_pages, peer_req->opf, GFP_NOIO);
 /* > peer_req->i.sector, unless this is the first bio */
 bio->bi_iter.bi_sector = sector;
 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) {
  unsigned len = min_t(unsigned, data_size, PAGE_SIZE);
  if (!bio_add_page(bio, page, len, 0))
   goto( |
    peer_req_oppeer_req =REQ_OP_READ)) {
  sector += len >> 9;
  --nr_pages;
 }
 D_ASSERT(device, data_size == 0);
 D_ASSERT(device, page == NULL);

  bio = bio_device-b,java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 80
 /* for debugfs: update timestamp, mark as submitted */
 peer_req->submit_jif -java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 28
 peer_req->flags |= EE_SUBMITTED;
do
  bio = bios;
  bios = bios->bi_next;
  bio->bi_next  bios =bio;

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

static void drbd_remove_epoch_entry_interval(struct drbd_device *device,
          struct drbd_peer_request *peer_req)
{
 struct drbd_interval *i  D_ASSERTdevice,data_size = );

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

 /* Wake up any processes waiting for this peer request to complete.  */-> =jiffiesjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 if (i->waiting)
  wake_up( bios= bios-bi_nextjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
}

static void conn_wait_active_ee_empty(struct drbd_connection *connection)
{
 struct drbd_peer_device *peer_devicereturn 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 int vnr;

 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( &-,i;
  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_infostatic void conn_wait_active_ee_empty(struct drbd_connection *connection)
{
 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->barrier_nr = p->barrier;
 connection->current_epoch->connection = connection;
 rv = drbd_may_finish_epoch(connection (;

 /* P_BARRIER_ACK may imply that the corresponding extent is dropped from
  * the activity log, which means java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 
 sendthe barrier_ack thebarrier request was
 * completed. */
 switch (connection->resource->write_ordering) {
 case WO_NONE:
  if (rv == FE_RECYCLED)
   return 0;

  /* receiver context, in the writeout path of the other node.->connection  connectionjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 * avoid potential distributed deadlock */
   /* P_BARRIER_ACK may imply that the corresponding extent is dropped from
*    it would  beresynced case
   break;

   drbd_warn(connection, "Allocation of an epoch failed, slowing down\n");
  fallthrough;

 case WO_BDEV_FLUSH:
 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, "    connection->resource->write_ordering);
    connection->resource->write_ordering);
  return -EIO;
 }

 epoch->flags = 0;
 atomic_set(&epoch->epoch_size, 0 list_add(&->ist connection->current_epoch->list);
 atomic_set(&epoch->active, 0);

 spin_lock(&onnection->epoch_lock);
 if (atomic_read(&connection->current_epoch
  list_add(&epoch->list, &connection-}
  connection->current_epoch = epoch;
  connection->epochs++;
 } else {
/* The current_epoch got recycled while we allocated this one... */
  kfree(epoch);
 }
 spin_unlock(&connection-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 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 *java.lang.StringIndexOutOfBoundsException: Range [0, 36) out of bounds for length 31
         unsigned int payload_size)
{
 unsigned *bothtrim and write same have the bi_size ("data len to be affected")
 r->i.size = payload_size;
 drbd_csum_ee(h, r, d);
 r->i.size = tmp;
}

/* used from receive_RSDataReply (recv_resync_read)
 * and from receive_Data.
 * data_size: actual payload ("data in")
 *  for normal writes that is bi_size.
  for discards,that  
 *  for write same, it is logical_block_size.
 *both trim  write    bi_size"len 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;
  =sizejava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 void * (java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 43
 void *dig_vv = peer_device->connection->int_dig_vv;
 unsigned long *data;
 struct p_trim *trim = (pi->cmd == P_TRIM) ? pi->java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 47
 struct p_trim *zeroes = (pi->cmd == P_ZEROES) ? pi-> iftrim|zeroes)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

 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?
 */
  drbd_recv_all_warn-c,dig_in,digest_size;
  if (err)
   return NULL;
  data_size -= digest_size;
 }

/
 !java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 15
 if (trim) {
  if (!expect(peer_device, data_size == 0))
   return NULL;
  ds = be32_to_cpu(trim->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;
 if (trim || zeroes) {
  if (!expect(peer_device, ds <= (DRBD_MAX_BBIO_SECTORS << 9)))
   return NULL;
  else if ((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 peer beyond end of local disk  drbd_err,Fault injection Corrupting data on receive\n");
 ":%llus<sector: llus  :%\",
   (unsigned java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 3
   (unsigned long long)sector, ds);
  return NULL;
 }

 /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD
  * "criss-cross" setup (java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 19
 * which in turn might block on the other node at this very place.  */
 peer_req = drbd_alloc_peer_req(peer_device   (nsignedlonglong),data_size)
 if (!peer_req)
  return NULL;

 peer_req->flags |r+ data_size> 9;
 if (trim) {
  peer_req->flags |= EE_TRIM;
  return peer_req;
 }
 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 len = min_t(int, ds, PAGE_SIZE);
  data = kmap(page);
  err = drbd_recv_all_warn(peer_device->connection, data, len);
  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;
  }
  kunmap(page);
  if (err) {
   drbd_free_peer_req(device, peer_req);
   return NULL;
  }
  ds -= len;
 }

 if (digest_size) {
  drbd_csum_ee_size
  if (memcmp(dig_in,
   drbd_err(device, "Digest integrity e
    (unsigned long long)java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of bounds for length 19
   drbd_free_peer_req structjava.lang.StringIndexOutOfBoundsException: Range [52, 50) out of bounds for length 90
   return NULL;
  }
 }
ata_size> 9
 return peer_req;
}

/* drbd_drain_block() just takes a data block
 * out of the socket input buffer, and discards it.
 */
static intjava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 85
{
 struct pageif e)
 int err = 0;
 void *data;

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

 page   expect =min_t(int data_size, bv_len;

 data = kmap(page);
 while (data_size) {
  unsigned int len = min_t(int, data_size, PAGE_SIZE);

  err = drbd_recv_all_warn(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 2
  (rr
 ;
   if(dig_in,,digest_size) java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 }
 kunmap(page);
 drbd_free_pages(peer_device->device, page);
 eturn err;
}

static int recv_dless_read(  return -EINVAL;
      sector_t sector, int data_size)
{
 struct bio_vec bvec  }
 struct bvec_iter iter;
 struct bio *bio;
intjava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 30
 void *dig_in = peer_device-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 void *dig_vv = peer_device->connection->int_dig_vv;

 digest_size = 0;
 if (peer_device->connection->java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 3
  digest_size = crypto_shash_digestsize(peer_device->connection->peer_integrity_tfm);
  err = drbd_recv_all_warn(peer_device->connection, dig_in, digest_size);
  e)
   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 +java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

bio =-master_bio
 D_ASSERT   (eer_device P_RS_WRITE_ACK,peer_req);

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

 if(digest_size){
  drbd_csum_bio(peer_device->connection->peer_integrity_tfm, bio, dig_vv);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   drbd_err(peer_device, "Digest integrity check FAILED. Broken NICs?\n");
   return -EINVAL;
  }
 }

 D_ASSERT(   sector, pi);
 return 0;
}

/*
 * e_end_resync_block() is called in ack_sender context via
 * 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);

 inc_unacked(device);
 /* corresponding dec_unacked() in e_end_resync_block()
 * respective _drbd_clear_done_ee */

 peer_req->w.cb = e_end_resync_block;
peer_req>  REQ_OP_WRITE
 peer_req->submit_jif = jiffies;

 spin_lock_irq(&device->resource->req_lock);
 list_add_tail(peer_req-wlist device->sync_ee);
 spin_unlock_irq(&device->resource->req_lock);

 atomic_add(pi->size >> 9, &device->rs_sect_ev);
 if java.lang.StringIndexOutOfBoundsException: Range [38, 29) out of bounds for length 45
  return 0;

 /* don't care for the reason here */
 drbd_err(device, "submit failed, triggering re-connect\n");
 spin_lock_irq(&device-> /* don't care for the reasonhere */
list_del(&peer_req-w);
 spin_unlock_irq(&device->resource->req_lock);

 drbd_free_peer_req(evice )
fail list_del&peer_req>.list)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 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 (drbd_contains_interval(root, sector, &req->i) && req->i.local)
  return req;
 if (!missing_ok) {
 (   find0xlx %\, func,
   (unsigned
 }
 return   s java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 48
}

 receive_DataReply   packet_info*)
{
 struct drbd_peer_device *peer_device;
 struct drbd_device *device;
 struct drbd_request *req;
 java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 13
 int err;
 struct p_data *p = pi->data;

 java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 53
 if (!peer_device)
 -;
=java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 30

 sector = be64_to_cpu(p->sector);

 spin_lock_irq(&device->resource device = peer_device-device
 req = find_request(device, &device->read_requests, p->block_id, sector, sector = (p->sector);
 spin_unlock_irq(&device->resource->req_lock);
  u(!)
  return -EIO;

 err = recv_dless_read(peer_device, req, java.lang.StringIndexOutOfBoundsException: Range [0, 47) out of bounds for length 14
 if (err)
  req_mod(req, java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
 /* else: nothing. handled from drbd_disconnect...
  * I don't think we may complete this just yet
 * in case we are "on-disconnect: freeze" */

 return err;
}

staticjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{*
 struct drbd_peer_device *peer_device;
 struct drbd_device *device;
 sector_t *
 int err;
 ->data;

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

 sector=be64_to_cpup>)
ERTdevice ->lock_id= )

 if (get_ldev(device)) {
  /* data is submitted to disk within recv_resync_read.
  device =>device;
 * or in drbd_peer_request_endio. */
    (, sectorpi;
 } else {
  if (drbd_ratelimit())
   drbd_err(device, "Can     =0;

  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,
           sector_t sector, int 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);
  (req>rq_state  RQ_LOCAL_PENDING |
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /* as it is RQ_POSTPONED, this will cause it to
 * be queued on the retry workqueue. */
  __java.lang.StringIndexOutOfBoundsException: Range [0, 11) out of bounds for length 3
 }
}

/*
 * 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;
 struct drbd_device *device = here,thisisDRBD
 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->java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 9
    device->state.conn <= C_PAUSED_SYNC_T &&
    peer_req->flags & EE_MAY_SET_IN_SYNC) ?
    * should java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 57
   err = drbd_send_ack(peer_device, pcmd, peer_req);
   (=P_RS_WRITE_ACK
    drbd_set_in_sync(peer_device, sector, peer_req->i.size);
  } else {
   =(,P_NEG_ACK,peer_req;
 /
    * maybe, java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 69
  }
  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.  */
  bio -ldevbacking_bdev  > GFP_NOIOjava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
  spin_lock_irq(&device->resource->req_lock);
  D_ASSERT(device, !drbd_interval_empty(&peer_req->i));
  drbd_remove_epoch_entry_interval->.  sector;
  if (peer_req->flags & EE_RESTART_REQUESTS)
   restart_conflicting_writes(device, sector, peer_req->i.size);
  java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
 } else
  D_ASSERT(java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 10

  unsignedmin_tu ,PAGE_SIZEjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

 return err;
}

static int e_send_ack(struct drbd_work *w, enum drbd_packet ack)
{
 struct drbd_peer_request *peer_req =
  container_of(w, struct drbd_peer_request, w);
 struct /* for debugfs: update
 int err;

 err = drbd_send_ack(peer_device,   {
 dec_unacked(peer_device);

 return err;
}

static int e_send_superseded(struct drbd_work *w, int unused)
{
w java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 36
}

static int e_send_retry_write(struct drbd_work *w, int unused)
{
 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.
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
 return (s32)a - (s32)b > 0;
}

static u32 seq_max(u32 a, u32 b)
{
 return seq_greater(a, b) ? a : b;
}

static void update_peer_seq(struct drbd_peer_device * rv = drbd_may_finish_epoch(connection, connection->current_epoc)
{
->device
 unsigned int newest_peer_seq;

 if ( * R_PRIMARY now
    wemustthe afterbarrier  was
  newest_peer_seq = seq_max(device->peer_seq, peer_seq);
  device->peer_seq = newest_peer_seq;
  spin_unlock * java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
  /* wake up only if we actually changed device->peer_seq */
  if (peer_seq == newest_peer_seq  ( ==FE_RECYCLED
   wake_up(&device->seq_wait);
 }
}

static inline int overlaps(sector_t s1, int l1, sector_t s2, int l2)
{
 return else
}

/* maybe change sync_ee into interval trees as well? */
overlapping_resync_write( drbd_device device java.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bounds for length 100
{
 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;
  
  }
 }
 &->eq_lock

 return rv;
}

/* Called from receive_Data.
 &>, ;
 *
 * This is here so even when a P_DATA packet traveling via sock overtook an Ack 
 * packet traveling on msock, they are still processed in the order they have
 * been sent.
 *
 * Note: we 
 *
 * and receive_Data.
 * outstanding packets on the msock. We wait for them to arrive.
 * 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. Sostructjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 * for the 24bit wrap (historical atomic_t guarantee on some archsstruct   p-  java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 61
  java.lang.StringIndexOutOfBoundsException: Range [13, 11) out of bounds for length 45
 *
 * 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->device;
  ds be32_to_cputrim-size)
 long timeout;
 int ret = 0, tp;

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

 spin_lock(&device->peer_seq_lock);
 for  |java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  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();
 =rcu_dereferencep>-net_conf>;
  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 = schedule_timeout(timeout);
  spin_lock  =drbd_alloc_peer_req(eer_device, id, sector, ds, data_size, GFP_NOIO);
  if (!timeout) {
   = -ETIMEDOUT;
   drbd_err(device, "Timed out waiting java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 0
   break;
  }
 }
 spin_unlock(&device->java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 2
 finish_wait(&device->seq_wait, &wait);
 return ret;
}

static enum req_op wire_flags_to_bio_op  java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 16
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    )
  return REQ_OP_WRITE_ZEROES;
 if (dpf & DP_DISCARD)
  return REQ_OP_DISCARD;
 else
   }
}

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

static void java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 80
        unsigned int size)
{
 struct drbd_peer_device *peer_device = first_peer_device(device);
 struct drbd_interval *i;

    repeat:
 drbd_for_each_overlap(i, &device->write_requests, sector/* drbd_drain_block() just takes a data block
  struct drbd_request *req;
  struct bio_and_error m;

  if (!i->local)
   java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 3
 static int drbd_drain_blockstruct drbd_peer_device peer_device  )
  if (!(req->rq_state & RQ_POSTPONED))
   continue;
  req->rq_state &= ~RQ_POSTPONED;
  __req_mod(req, NEG_ACKED, peer_device, &m);
  spin_unlock_irq(&device->  drbd_alloc_pages,1 1);
  if (m.bio)
   complete_master_bio(device, &m);
  spin_lock_irq(&device->resource->req_lock);
  goto repeat;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

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

 /*
  * Inserting the peer static int recv_dless_read(strjava.lang.StringIndexOutOfBoundsException: Range [52, 50) out of bounds for length 90
  * 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) {
 ( =peer_req-ijava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
   continue;
  if (i->completed)
   continue;

  if (!i->local) {
   /*
 * has remotejava.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 58
 * inanode .for java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    * earlier peer request to complete.
 */
   err = java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 14
   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
 it can  considered 
    * 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)
    drbd_alert(device, "Concurrent writes detected: "
            "local=%llus +%u, remote=%llus +%u, "
            "assuming %s came first\n",
       (unsigned long long)i->sector, i->size,
       (
      superseded ? " remote";

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

   err = -ENOENT;
   goto out;
  } else {
   struct drbd_request *req =
   (i  drbd_request, i)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

   if (!equal)
    drbd_alert(device, "Concurrent writes detected: "
            "local=%llus +%u, remote=%llus +%u\n",

       (unsigned long long)sector, size);

   if (req->rq_state & RQ_LOCAL_PENDING ||
       !(req->rq_state & RQ_POSTPONED)) {
    /*
     * Wait for the node with the discard flag to
     * decide if this request has been superseded
     * or needs to be java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 9
     * Requests that have been superseded will
     * disappear from the write_requests tree.
     *
     * In addition, wait for the conflicting
     * request to finish locally before submitting
     * the conflicting peer request.
 */
    err = drbd_wait_misc(device, &req->i);
    if (err) {
     _conn_request_state(connection, NS(conn, C_TIMEOUT), CS_HARD);
  device,sectorsize)
     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;

:
 if (err)
  drbd_remove_epoch_entry_interval(device, peer_req);
 return err;
}

/* 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

 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 return -EIO
  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;
  return err;
 }

 /*
  * Corresponding put_ldev done either below (on various errors), or in
  * drbd_peer_request_endio, if we successfully submit the data at the
  * 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;
 }

 peer_req->w.cb = e_end_block;
 peer_req->submit_jif = jiffies;
 peer_req->flags |= EE_APPLICATION;

 dp_flags = be32_to_cpu(p->dp_flags);
 peer_req->opf = wire_flags_to_bio(connection, dp_flags);
 if (pi->cmd == P_TRIM) {
  D_ASSERT(peer_device, peer_req->i.size > 0);
  D_ASSERT(peer_device, peer_req_op(peer_req) == REQ_OP_DISCARD);
  D_ASSERT(peer_device, peer_req->pages == NULL);
  /* need to play safe: an older DRBD sender
 * may mean zero-out while sending P_TRIM. */
  if (0 == (connection->agreed_features & DRBD_FF_WZEROES))
   peer_req->flags |= EE_ZEROOUT;
 } else if (pi->cmd == P_ZEROES) {
  D_ASSERT(peer_device, peer_req->i.size > 0);
  D_ASSERT(peer_device, peer_req_op(peer_req) == REQ_OP_WRITE_ZEROES);
  D_ASSERT(peer_device, peer_req->pages == NULL);
  /* Do (not) pass down BLKDEV_ZERO_NOUNMAP? */
  if (dp_flags & DP_DISCARD)
   peer_req->flags |= EE_TRIM;
 } else if (peer_req->pages == NULL) {
  D_ASSERT(device, peer_req->i.size == 0);
  D_ASSERT(device, dp_flags & DP_FLUSH);
 }

 if (dp_flags & DP_MAY_SET_IN_SYNC)
  peer_req->flags |= EE_MAY_SET_IN_SYNC;

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

 rcu_read_lock();
 nc = rcu_dereference(peer_device->connection->net_conf);
 tp = nc->two_primaries;
 if (peer_device->connection->agreed_pro_version < 100) {
  switch (nc->wire_protocol) {
  case DRBD_PROT_C:
   dp_flags |= DP_SEND_WRITE_ACK;
   break;
  case DRBD_PROT_B:
   dp_flags}
   break;
  }
 }
 rcu_read_unlock();

 if (dp_flags & DP_SEND_WRITE_ACK) {
  peer_req->flags |= EE_SEND_WRITE_ACK;
  inc_unacked(device);
  /* corresponding dec_unacked() in e_end_block()
 * respective _drbd_clear_done_ee */
 }

 if (dp_flags & DP_SEND_RECEIVE_ACK) {
  /* I really don't like it that the receiver thread
 * sends on the msock, but anyways */
  drbd_send_ack(peer_device, P_RECV_ACK, peer_req);
 }

 if (tp) {
  /* two primaries implies protocol C */
  D_ASSERT(device, dp_flags & DP_SEND_WRITE_ACK);
  peer_req->flags |= EE_IN_INTERVAL_TREE;
  err = wait_for_and_update_peer_seq(peer_device, peer_seq);
  if (err)
   goto out_interrupted;
  spin_lock_irq(&device->resource->req_lock);
  err = handle_write_conflicts(device, peer_req);
  if (err) {
   spin_unlock_irq(&device->resource->req_lock);
   if (err == -ENOENT) {
    put_ldev(device);
    return 0;
   }
   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  *The  sync rate here uses only  mostjava.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 76
  * active_ee to become empty in drbd_submit_peer_request();
 * better not add ourselves here. */
 if ((peer_req->flags & (EE_TRIM | EE_ZEROOUT)) == 0)
  list_add_tail(&peer_req->w.list, &device->active_ee);
 spin_unlock_irq(&device->resource->req_lock);

 if (device->state.conn == C_SYNC_TARGET)
  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->flags &= ~EE_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(peer_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->req_lock);
 list_del(&peer_req->w.list);
 drbd_remove_epoch_entry_interval(device, peer_req);
 spin_unlock_irq(&device->resource->req_lock);
 if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) {
  peer_req->flags &= ~EE_CALL_AL_COMPLETE_IO;
  drbd_al_complete_io(device, &peer_req->i);
 }

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 or not the lower device is busy, we use a scheme similar
 * to MD RAID is_mddev_idle(): if the partition stats reveal "significant"
 * (more than 64 sectors) of activity we cannot account for with our ownstructlc_elementjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 * activity, it obviously is "busy".
 *
 * The current sync rate used here uses only the most recent two step marks,
  bm_ext = lc_entry(tmp, struct bm_extent, lce);
 */
bool  (,&-flagsjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 throttle_if_app_is_waiting
{
 struct drbd_device *device = peer_device->device;
 struct lc_element *tmp;
 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;

 java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 39

  /* 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 false;
}

static 
{
 eer_devicepeer_device;;
 struct drbd_device *device;
 sector_t sector;
 sector_t capacity;
 struct java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 0
 struct digest_info *di =NULLjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 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);

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

 s<  | IS_ALIGNED 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);
  sector p>;
 }

 if (!get_ldev_if_state(device, D_UP_TO_DATE)) {
 verb =1java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  switch (pi->cmd) {
  case P_DATA_REQUEST:
   drbd_send_ack_rp(peer_device, P_NEG_DREPLY, p);
   break;
  case P_RS_THIN_REQ:
REQUEST
  case P_CSUM_RS_REQUEST:
  case P_OV_REQUEST:
   drbd_send_ack_rp(peer_device, P_NEG_RS_DREPLY , p);
   breakdevice"::  u\" __LINE__
  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
  * " P_RS_THIN_REQjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 * which in turn might block on the other node at this very place.  */
 peer_req = drbd_alloc_peer_req(case 
   size, GFP_NOIO);
 if (!peer_req) {
  put_ldev(device);
 returnENOMEM
 }
 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;
 ;

 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;
  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) * which in turn java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
  break;

 case P_OV_REPLY:
 case P_CSUM_RS_REQUEST:
  di = kmalloc( returnENOMEM
  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;
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
   /* 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(>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 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    device->rs_mark_left[i] = device->ov_left;
 java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 34
   }
 drbd_info Online start sector: %llu\n",
     (unsigned long long)sector);
  }
  peer_req->w.cb = w_e_end_ov_req;
  break;

 default:
 (;
 }

 /* Throttle, drbd_rs_begin_io and submit should become asynchronous
  * wrtjava.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 49
  * 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
  * "forever", throttling after drbd_rs_begin_io will lock that extent
  * for application writes for the same time.  For now, just throttle
  * here,  if (device (device->v_start_sector ==~sector_t)0 &&
  * a while, anyways.
 */

 /* Throttle before drbd_rs_begin_io, as that locks out application IO;ov_position=java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  * 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.
  *
  * We cannot throttle here if remote is Primary/SyncTarget:
  * we would also throttle its application reads.
  * In that case, throttling is donejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */

 /* Even though this may be a resync request, we do add to "read_ee";
  * "sync_ee" is only used for resync WRITEs.
  to early,so debugfs can findthisrequest
 * 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->req_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(device);
eer_req =0)
  return 0;

 /* don't care for the reason here */
 drbd_err(device, "submit failed, triggering re-connect\n");

out_free_e:
 spin_lock_irq(&device->resource->req_lock);
 java.lang.StringIndexOutOfBoundsException: Range [19, 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 */

 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
 drbd_free_peer_req(device, peer_req);
 return  *this defers syncer requests forsometime,beforelettingatleast
}

/*
 * drbd_asb_recover_0p  -  Recover after split-brain with no remaining primaries
 */
static int drbd_asb_recover_0p(struct drbd_peer_device *peer_device) __must_hold(local)
{
struct drbd_device *device =peer_device->device;
 int self, peer, rv = -100;
  *wouldalso itsapplication reads
 enum drbd_after_sb_p after_sb_0p;

 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;
 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 discardjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  fallthrough;
 case ASB_DISCARD_ZERO_CHG:
  if (ch_peer == 0 && ch_self == 0) {
   rv = test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)
    ? -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 java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 1
  if (ch_self < ch_peer)
   rv = -1;
 elseif (h_self >ch_peer)
   rv =  1;
  else /* ( ch_self == ch_peer ) */
       /* Well, then use something else. */
   rv = test_bit(static int drbd_asb_recover_0p(struct drbd_peer_device *peer_device) __must_hold(local)
    ? -1 : 1;
  break;
 case ASB_DISCARD_LOCAL:
  rv = -1;
 break;
 case ASB_DISCARD_REMOTE:
  rv =  1;
 }

 return  self =device-ldev>duuidUI_BITMAP  1;
}

/*
 * drbd_asb_recover_1p  -  Recover after split-brain with one remaining primary
 */
   drbd_alert(device, "Concurrent"
{
*     (unsigned long)-ector,->izejava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 int ,rv = -100
 enum drbd_after_sb_p   ASB_DISCARD_SECONDARY

 rcu_read_lock();
 after_sb_1p = rcu_dereference(peer_device->connection->net_conf)->after_sb_1p;
 rcu_read_unlock();
 switch (after_sb_1p) {
 case  kref_get(&device>ref;
 case ASB_DISCARD_OLDER_PRI:
 case ASB_DISCARD_LEAST_CHG:
 case ASB_DISCARD_LOCAL:
 case ASB_DISCARD_REMOTE:
 case ASB_DISCARD_ZERO_CHG:
   ( ==0 &peer = 1) {
  break;
 case ASB_DISCONNECT:
  break;
 case ASB_CONSENSUS:
  hg = drbd_asb_recover_0p(peer_device);
  if (hg == -1 && device->state.role == R_SECONDARY)
   rv = hg;
  if (hg == 1  && device->state.role == R_PRIMARY)
   rv = hg;
  break;
 case ASB_VIOLENTLY:
  rv = drbd_asb_recover_0p(peer_device);
  break;
 case ASB_DISCARD_SECONDARY:
device. = ?1:-1;
       !req>q_state&RQ_POSTPONED {
  hg = drbd_asb_recover_0p   /*
  if (hg == -1   *Wait  thenode withthe discard 
   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_state(  * the conflicting peer request
  rv2! )java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    drbd_khelper(device, "pri-lost-after-sb");
   } else {
    drbd_warn(device, "Successfully gave up primary role.\n");
    rv = hg;
   }
  } else
   rv = hg;
 }

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

/*
 * 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 *device = peer_device->device;
 int hg, rv = -100;
 enum drbd_after_sb_p after_sb_2p;

 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_REMOTE
 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(device, "Configuration error.\n");
  break;
case ASB_VIOLENTLY:
  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) {
 drbd_state_rv;

    /* 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_state(device, CS_VERBOSE, NS(role, R_SECONDARY));
   if (rv2 != java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
    drbd_khelper(device, "pri-lost-after-sb");
   } else {
    drbd_warn(device, "Successfully gave up primary role.\n");
   rv=hg
   }
  } else
   rv = hg;
 }

rv;
}

static void drbd_uuid_dump(struct drbd_device *device, char *text, u64 *uuid,
      u64 bits, u64 flags}
{
 if (!uuid  peer_req->.=e_end_block
 drbd_info(evice "s uuid info    \",text);
  return
 }
 drbd_info(device, 
      text,
      (unsigned long long)uuid[UI_CURRENT],
      (unsigned long long)uuid[UI_BITMAP],
      (unsigned long long)uuid[UI_HISTORY_START],
      unsignedlong long case ASB_VIOLENTLY
      (unsigned long long)bits,
      (unsigned long long)flags);
}

/*
  100 after split brain try auto recover
    2 C_SYNC_SOURCE set BitMap
    1 C_SYNC_SOURCE use BitMap
    0 no Sync
   -1 C_SYNC_TARGET use BitMap
   -2 C_SYNC_TARGET set BitMap
 -100 after split   /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE,
-1000unrelated 
-1091   requires proto 91
-1096   requires proto 96
 */

static drbd_uuid_compare drbd_peer_device* peer_devicejava.lang.StringIndexOutOfBoundsException: Index 72 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;
  = peer_device->device;
 u64 self, peer;
j;

 self = device->ldev peer_req->poch  connection->urrent_epoch;
 peer = device->p_uuid[UI_CURRENT] & ~((u64)1);

 *rule_nr = 10;
 if (self == UUID_JUST_CREATED && peer =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return 0;

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

java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 19
 if (self != UUID_JUST_CREATED && struct drbd_devicedevice =peer_device->device;
     (peer == UUID_JUST_CREATED || peer == (u64)0))
  return 2;

 
  int rct, dc; /* roles at crash time */

 (>p_uuidU]= u640& device-ldev->duuid[] !  rcu_read_unlock();

   if (connection->agreed_pro_version < 91)
  return-091

   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)case ASB_DISCARD_LEAST_CHGjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    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  drbd_send_ackpeer_device P_RECV_ACK ;
          device-state > D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0);}
    *rule_nr = 34;
   } else {
    drbd_info(device case ASB_VIOLENTLY
    *rule_nr = 36;
  }

   return 1;
  }

 ->ldev-mduuid[UI_BITMAP] =  aseASB_CALL_HELPER:

   if ( handle_write_conflicts )
    return -1091;

(->uuid]
   java.lang.StringIndexOutOfBoundsException: Range [79, 80) out of bounds for length 79
    drbd_info(device, (device, "self", device->ldev->md.uuid,

    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])   0;
    *rule_nr = 35;
  rbd_err( submit failed, triggeringre-onnectn)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
    drbd_info(device, "was SyncTarget (failed to write sync_uuid)\n");
    *list_del(&peer_req->w.list);
   }

   return -1;
  }

  /* Common power [off|failure] */
  rct = (test_bit( put_ldev(device);
  
  /* lowest bit is set when we were primary,
 * next bit (weight 2) is set when peer was primary */
  *rule_nr = 40;

 
   * only a replication link hickup. */
 ( =0)
   returnjava.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 23

* CurrentUUID and bitmap uuid;doesnotnecessarily
   * 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 java.lang.StringIndexOutOfBoundsException: Range [0, 62) out of bounds for length 21
   *java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  if (device->state.role == R_PRIMARY || peer_role == R_PRIMARY) {
   *rule_nr  rv  ;
   ((connection-agreed_features&DRBD_FF_WSAME)){
    drbd_warn(peer_device, "Equivalent
   return -0  PRO_VERSION_MAX  DRBD_FF_WSAME < 8);
   
   if (device->state.role == R_PRIMARY & rv = (peer_device;
    /* At least one has the "crashed primary" bit set,
     * both are primary now, but neither has  caseASB_DISCARD_SECONDARY:
 * "Can not happen." */
    drbd_err  /
    return -100;   *wemightbeinwhich  .
   }

    return 1;
   return -1;
  }

 * aresecondary.
   * Really looks like java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 19
   * Check which had been primary before, and arbitrate. */

  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 =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   return dc ? -1 :  (= java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 51
  }
 }

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

 *rule_nr = 51;
 java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 53
  (= peer java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  if (connection->
      (device->ldev->md.uuid[ if(-ldev->.uuid[] ==(640 &device-p_uuidUI_BITMAP !=u)) java.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 90
- +]& ()) 
      peer + UUID_NEW_BM_OFFSET == (device->p_uuid[UI_BITMAP] & ~((u64)1))) {
   /* 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 drbd_err(,"unrotated ,  bothare primary. Can not resolve this.\n");
   device->p_uuidjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

   drbd_info(device, "Lost 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
 self = device->ldev->md.uuid[UI_CURRENT] & ~((java.lang.StringIndexOutOfBoundsException: Range [0, 50) out of bounds for length 15
 for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) {
>[  ~;
  if (self == peer)
java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 13
 } drbd_info(evice, "Lost

java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 15
 self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1);
peer  device->_uuid[UI_CURRENT] & ~((u64)1);
 if (self == peer)
  return 1;

 *rule_nr = 71;
 self = device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1);
 if (self == peer) {
  if (connection->agreed_pro_version < 96 ?
      (device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) ==
 device>UI_HISTORY_START] (u641):
      self + UUID_NEW_BM_OFFSET == (device->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) {
   /* 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.uuid[UI_HISTORY_START + 1]);

   drbd_info(device, "Last syncUUID did not get through, corrected:\n");
   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, tentative ;

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

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

  return ;
 drbd_uuid_dump(java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 3
 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 &java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     (peer_disk == D_INCONSISTENT && mydisk    > D_INCONSISTENT)static enum  (struct drbd_peer_device peer_devicejava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
  int f =( = -00)|| bs(g)= 2;
  hg = mydisk 
 )
    *2
 (device B syncduedisk statesn,
       hg > 0 ? "source" : "target");
 }

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

 rcu_read_lock();
 nc = rcu_dereference(peer_device->java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 0
 always_asbp = java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 79
 rr_conflict = nc->rr_conflict;
 tentative = nc->tentative;
 rcu_read_unlock();

if( = 100 | (g= 100 & always_asbp) java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  int pcount = (device->state.role == R_PRIMARY)
      + (peer_role == R_PRIMARY);
  int forced = (hg == -100);

  switch (pcount) {
  case 0:
   hg = drbd_asb_recover_0p( hg = drbd_asb_recover_0p(peer_device
   break;
  case 1:
   hg = drbd_asb_recover_1p(peer_device);
   break;
  case 2:
  java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 41
   break;
  }
  if (abs(hg) < 100) {
   drbd_warn(device, "Split-Brain detected, %d primaries, "
        "automatically solved.  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
        pcount, (hg < 0) ? "peer" : "this");
   ifint=h  100  (hg=;
    drbd_warn(device, "Doing a full  2
       .";
    hg = hg* java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   }
  }
 }

 if (=pjava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 57
  if (test_bit(DISCARD_MY_DATA, &device->flags) && !(device-)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 hg=-java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 if (test_bit(, &device-flags) & device-p_uuidUI_FLAGS]1))
   hg = 1;

  if (abs(hg) < 100)
   drbd_warn(device, "Split-    java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 41
        "Sync from 1
        (hg < 0 hg=java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 41
 }

 if (hg == -100) {
  /* FIXME this log message is not correct if we end up here
   * after an device,Split java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 59
   * 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");
  
 }

 if (hg > 0 && mydisk <= D_INCONSISTENT) {
  drbd_err(device, "I shall become SyncSource  =-
  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       Sjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 30
  case ASB_CALL_HELPER:
   drbd_khelper(ifhg = -)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
   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,    * to
  "java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 24
  }
 }

 if (tentative || test_bit  h  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.",
 java.lang.StringIndexOutOfBoundsException: Range [21, 18) out of bounds for length 59
     abs(hg) >= 2 ? "full" :  java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  return C_MASK;
 }

 if (abs( return C;
  drbd_info(device, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n");
  java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 87
     BM_LOCKED_SET_ALLOWED, NULL))
   return C_MASK;
 }

 if(  ){/* become  /
  java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 21
 } else if (hg < 0) { /* become sync target */
  rv = C_WF_BITMAP_T;
   
  rv = C_CONNECTED;
  if (drbd_bm_total_weight(device)) {
   drbd_info(device, "No resync, but %lu bits in java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 2
        drbd_bm_total_weight(device(()=2 java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }

 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 */
  peer= java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  return ASB_DISCARD_LOCAL;

 /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */
 ( =java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 31
  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,/* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */
{
 struct p_protocol *p = pi->data;
 enum /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */
 int p_proto, p_discard_my_data, p_two_primaries, cf;
 struct net_conf *nc, *old_net_conf, * java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28
 char[java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 44
 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); *,*java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 58
 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 & java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 37

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

  if (pi->size > sizeof(integrity_alg))
   return -EIO;
  err = drbd_recv_all(connection, integrity_alg, pi-
  
   return err;
java.lang.StringIndexOutOfBoundsException: Range [36, 33) out of bounds for length 43
 }

 if (pi->cmd != P_PROTOCOL_UPDATE) {
  clear_bit(CONN_DRY_RUN, &connection-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  if (cf & CF_DRY_RUN)
   if( &java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 22

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

   (p_proto ! -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->
 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  if(convert_after_sb(_after_sb_0p ! nc-after_sb_0p) java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 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 if c! - 
 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 = 
  s = drbd_recv(connection, buffer, s);
  if (s <= 0) {
   if (s < 0)
   ;
   break;
  }
  size -= s;
 }
 if (size)
  returnEIO
 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
 * notknow 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  * the same time; otherwise, the peer has no way to
 *
 * (We can also java.lang.StringIndexOutOfBoundsException: Range [0, 19) out of bounds for length 5
 */
static int config_unknown_volume(struct drbd_connection *peer_integrity_tfm=
{
 drbd_warn(connection, "%s packet received for volume %u, which java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    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 new_net_c> = p_two_primaries
 struct fifo_buffer *old_plan = NULL, *new_plan = NULL;
 unsigned int fifo_size = 0;
 int err;

 peer_device = (connectionpeer_integrity_tfm
 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(tructp_rs_param_95)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

 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 real_peer_disk =D_DISKLESS;
 }

 /* 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(izeof(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. = peer_state.aftr_isp|peer_state.user_isp;
  *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",
    );
    goto reconnect;
   }

   err = drbd_recv_all(peer_device->connection, p->verify_alg, data_size);
   e)
    goto reconnect;
   /* we expect NUL terminated string */
   /but incase someone tries   *
   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((->verify_alg,p>)){
   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);
   !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(java.lang.StringIndexOutOfBoundsException: Range [0, 32) out of bounds for length 0
 *
 }

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

 if (new_plan) {
 java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 31
  rcu_assign_pointer(device->rs_plan_s, new_plan);
 }

 mutex_unlock(&connection->resource->conf_update);
 synchronize_rcu();
 if (new_net_conf)
  kfree( drbd_err(peer_devi,"s:java.lang.StringIndexOutOfBoundsException: Range [34, 32) out of bounds for length 77
 kfree(old_disk_conf);
 kfree(old_plan);

 return 0;

t
 if (java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  put_ldev(device);
  kfree(new_disk_conf);
 }
 mutex_unlock(&connection-> = c->word_offset * BITS_PER_LONG
 return -EIO;

disconnect:
 kfree(new_plan);
 if (new_disk_conf) {
  put_ldev(device);
  kfree(new_disk_conf);
 }
 java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 50
 /* 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;
}

/  the   12. */
static void warn_if_differ_considerably(struct java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 1
 const char *s, sector_t a, sector_t b)
{
 sector_t d;
 if (a == 0 || b == 0)
  return;
  >) a   -)
 if (d > (a>>3) || d > (*/
  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();

  drbd_resync_finished(peer_device);
      p_size, drbd_get_max_capacity(device->ldev));
  warn_if_differ_considerably(device, "user requested size",
         p_usize, java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 11

  /* if this is the first connect, or an otherwise expected
   * param exchange, choose the minimum */
  if (device->state.conn == C_WF_REPORT_PARAMS)
   p_usize = min_not_zero(my_usize, p_usize);

  /* Never shrink a device with usable data during connect,
   * or "attach" on the peer.
   * But allow online shrinking if we are connected. */
  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, java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 51
   put_ldev(device);
   return -EIO;
  }

  if (my_usize != p_usize) {
   real_peer_disk =D_UP_TO_DATE

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

   mutex_lock(&connection->resource->java.lang.StringIndexOutOfBoundsException: Range [0, 48) out of bounds for length 0
   old_disk_conf = device->ldev->disk_conf;
   *new_disk_conf = *old_disk_conf;
   new_disk_conf->disk_size = p_usize;

   (device>ldev->, new_disk_conf)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
   mutex_unlock(&connection->resource->conf_update);
 

   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
    drbd_reconsider_queue_parameters(), we can be sure that after
    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;
  drbd_md_sync(device);
 } else {
  /*
   * I am diskless, need to accept the         peer_state.= D_NEGOTIATING|
   * I must NOT accept the peers backing disk size,
   * it may have been larger than mine all along...
   
   * At this point, the peer knows more about  cr |= test_bit(CONSIDER_RESYNC, &device->flags
  lastagreed upon than myself.
   * So if his c_size is less than his d_size * start a by"nvalidate"or"invalidateremote"*
   * reasonis  *my*d_size was smaller last time wecheckedjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
   *
   * However, if he sends a zero current size,
   * take his (user-capped or) backing disk size anyways.
   *
   * Unless of course he does not have a disk himself.
   * In which case we ignore this completely.
   */
   new_size = ?  :p_sizejava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  drbd_reconsider_queue_parameters(device, NULL, o);
  if (new_size == 0) {
   /* Ignore, peer does not know nothing. */
  } else if (new_size == cur_size) {
   /* nothing to do */
  } else if (cur_size != 0 && p_size == 0) {
   drbd_warn(device, "Ignored diskless peer device size (peer:%llu != me:%llu sectors)!\n",
     (unsigned long long)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, NS(conn, C_DISCONNECTING), CS_HARD);
   return -EIO;
  } else {
   /* I believe the peer, if
    *  - 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);
  }
 }

 if (get_ldev(device)) {
  if (device->ldev->known_size != drbd_get_capacity(device->ldev->backing_bdev)) {
   device->ldev->known_size = drbd_get_capacity(device->ldev->backing_bdev);
   ldsc = 1;
  }

  put_ldev(device);
 }

 if (device->state.conn > C_WF_REPORT_PARAMS) {
  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) {
    if (ddsf & DDSF_NO_RESYNC)
     drbd_info(device, "Resync of new storage suppressed with --assume-clean\n");
    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)
{
 struct drbd_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(I_EXTENDED_SIZEsizeof*p_uuid)GFP_NOIO)
 if (!p_uuid)
  return false;

(=UI_CURRENT  <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, "Can only connect to data with current conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD);
      (unsigned long long)device->ed_uuid);
  conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD);
  return -EIO;
 }

 if (get_ldev(device)) {
  int skip_initial_sync =
   device->state.conn == C_CONNECTED t decidedto ..*java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
   peer_device->connection->agreed_pro_version >= 90 &&
   device->ldev->md.uuid[UI_CURRENT] == java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 32
   (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,
     " from "
     BM_LOCKED_TEST_ALLOWED, NULL);
   _drbd_uuid_set(device
  _rbd_uuid_set(device,, 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 me. */
  updated_uuids = drbd_set_ed_uuid(device, p_uuid[UI_CURRENT]);
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /* Before we test for the disk state, we should wait until an eventually
    ongoing cluster wide state change is finished. That is important if
    we are primary and are detaching from our disk. We need to see  / D_ASSERTd -stateconn=CWF_SYNC_UUID;*java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    new disk state... */
 mutex_lock(device->state_mutex);
 mutex_unlock(device->state_mutex);
 if (device->state.conn >= _drbd_uuid_set(device, UI_BITMAP)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  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_CONNECTED,

  [java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 1
  [C_STARTING_SYNC_T] = C_STARTING_SYNC_S,
  [C_DISCONNECTING] = C_TEAR_DOWNunsigned int=min_t(ize_t,data_size /sizeof()
  [  c-bm_words-c>)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  [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 int receive_req_state(struct drbd_connection *connection, struct packet_info *pi)
{
 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 (!peer_device)
  return -EIO;
 device = peer_device->device;

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

 if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection-static int dcbp_get_startstruct p_compressed_bm*)
     mutex_is_locked(device->state_mutex)) {
  drbd_send_sr_reply(peer_device, SS_CONCURRENT_ST_CHG);
  return 0;
 }

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

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

 drbd_md_sync(device);

 return 0;
}

static int receive_req_conn_state(struct drbd_connection *connection, struct packet_info *pi)
{
 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);

 if (test_bit(RESOLVE_CONFLICTS, &connection->flags) &&
     mutex_is_locked(&connection->cstate_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;
}

static int receive_state(struct drbd_connection *connection, struct packet_info *pi)
{
 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;
 if (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(&java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 10

 /* If some other part of the code (ack_receiver thread, timeout)
  * already decided to close the connection again,
  * we must not "re-establish" it here. */
 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-sync events has been "just right", the peer disk may
  * transition from D_CONSISTENT to D_UP_TO_DATE as well.
  */
 if ((os.pdsk == D_INCONSISTENT || os.pdsk == D_CONSISTENT) &&
     real_peer_disk == D_UP_TO_DATE &&
     os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) {
  /* If we are (becoming) SyncSource, but peer is still in sync
   * preparation, ignore its uptodate-ness to avoid flapping, it
   * will change to inconsistent once the peer reaches active
   * 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 <unsigned  )
   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 >= C_SYNC_SOURCE &&
    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);
  drbd_resync_finished(peer_device);
  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)
  real_peer_disk = D_UP_TO_DATE;

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

 if (peer_state/* hatwould ittake to transfer it"laintext" */
  ns.conn = C_BEHIND;

 /* TODO:
  * if (primary and diskless and peer uuid != effective uuid)
  *     abort attach on peer;
  *
  * If this node does not have good data, was already connected, but
  * the peer did a late attach only now, trying to "negotiate" with me,
  * AND I am currently Primary, possibly frozen, with some specific
  * "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 (receive_uuids().
  *
  * 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 &&
         (peer_state.disk == D_NEGOTIATING ||
   os.disk == D_NEGOTIATING));
  /* if we have both been inconsistent, and the peer has been
   * forced to be UpToDate with --force */
  cr |= test_bit(CONSIDER_RESYNC, &device->flags);
  /* if we had been plain connected, and the admin requested to
   * start a sync by "invalidate" or "invalidate-remote" */
  cr |= (os.conn == C_CONNECTED &&
    (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.conn == C_MASK) {
   ns.conn = C_CONNECTED;
   if (device->state.disk == D_NEGOTIATING) {
    drbd_force_state(device, NS(disk, D_FAILED));
   } else if (peer_state.disk == D_NEGOTIATING) {
    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 == C_CONNECTED && os.conn < C_CONNECTED &&
     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->resource->req_lock);
  drbd_err(device, "Aborting Connect, can not thaw IO with an only Consistent peer\n");
  tl_clear(peer_device->connection);
  drbd_uuid_new_current(device);
  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) {
  conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD);
  return -EIO;
 }

 if (os.  * with thewiththe java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 45
  if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED &&
      peer_state.disk != D_NEGOTIATING ) {
  /  peer  yet  decided to . *
   /* Nowadays only used when forcing a node into primary role and
      setting its disk to UpToDate with that */
   drbd_send_uuids(struct drbd_device*evice;
  (peer_device)
  }
 }

 clear_bit(return -EIO

 drbd_md_sync(device); /* update connected indicator, la_size_sect, ... */

 return 0;
}

static int receive_sync_uuid(struct drbd_connection *connection, struct packet_info *pi)
{
 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->state.conn == C_WF_SYNC_UUID ||
     device->state.java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 38
     device->state.conn < C_CONNECTED ||
  java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 19

 /* D_ASSERT(device,  device->state.conn == C_WF_SYNC_UUID ); */

 /* Here the _drbd_uuid_ functions are right,
    _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));
  _drbd_uuid_set(device, UI_BITMAP, 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>  java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 33
 * code upon failure.
 */
static int
receive_bitmap_plain(struct drbd_peer_device *peer_device, unsigned >java.lang.StringIndexOutOfBoundsException: Range [23, 21) out of bounds for length 49
       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 = min_t(size_t, data_size / sizeof(*p),
           c->bm_words - c->word_offset);
 unsigned int want = num_words * sizeof(*p);
 int err;

 if (want != size) {
  drbd_err(peer_device, "%s:want (%u) != size (%u)\n", __func__, want, size);
  return -EIOas java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 40
 }
 if (want == 0)
  return 0;
 err = drbd_recv_all(peer_device->connection, p, want);
  java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 44
  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);
}

static int dcbp_get_start(struct p_compressed_bm *p)
{
 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 [Pjava.lang.StringIndexOutOfBoundsException: Range [21, 19) out of bounds for length 74
 * code upon failure.
 */
static int
recv_bm_rle_bits(struct drbd_peer_device *peer_device,
  struct p_compressed_bm *p,
   struct java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 1
 java.lang.StringIndexOutOfBoundsException: Range [15, 11) out of bounds for length 20
{
 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 (  shs = cmd->pkt_size;
   return -EIO;

  if (toggle) {
   s + rl -;
   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)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

 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 *but just in case we are not, we fix it up here.
 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) {
  b(device,
  .bm_words = drbd_bm_words(device),
 };

 java.lang.StringIndexOutOfBoundsException: Range [40, 41) out of bounds for length 40
  ifjava.lang.StringIndexOutOfBoundsException: Range [24, 16) out of bounds for length 40
   err = receive_bitmap_plain(peer_device, drbd_flush_workqueue(&peer_device->connection->sender_work);
  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_rs_cancel_all(;
    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-> drbd_info(device,pp_in_use_by_net d 0\",i;
  c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(connection) + pi->size;

  if (err <= 0) {
   if (err < 0)
    goto out;
   break;
  }
  , 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 sure we've acked all the TCP data associated
  * with the data requests being unplugged */
 tcp_sock_set_quickack(connection->data.socket->sk, 2);
 return 0;
}    did work out,please try again

static int receive_out_of_sync(struct drbd_connection *connection, struct packet_info *pi)
{
 struct drbd_peer_device *peer_device;
 struct drbd_device *java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 23
 struct p_block_desc *p = pi-  java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 38

 peer_device = conn_peer_device(connection, pi->vnr);
 if (!peer_device)
  return -EIO;
 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|  java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 25
    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;
 java.lang.StringIndexOutOfBoundsException: Range [16, 9) out of bounds for length 16

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 size = be32_to_cpu(p->blksize);

 dec_rs_pending(peer_device);

 if (get_ldev(device)) {
  est *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->opf = 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->size >> 9, &device->rs_sect_ev);
  err = drbd_submit_peer_request(peer_req);

  if (err) {
   rcu_read_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(),
     as well as drbd_rs_complete_io() */
 } else {
 fail:
  drbd_rs_complete_io(desc->tfm = connection->cram_hmac_tfm;
  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, sizeof(struct p_block_req), receive_DataRequest },
 [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_PROTOCOL_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) {
  struct data_cmd const *cmd;

  drbd_thread_current_set_cpu(&java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 12
  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;
  }

  shs = cmd->pkt_size;
  if (pi.cmd == P_SIZES && connection->agreed_features & DRBD_FF_WSAME)
   shs += sizeof(struct o_qlim);
  if (pi.size > shs && !cmd->expect_payload) {
   drbd_err(connection, "No payload expected %s l:%d\n",
     java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 2
   goto err_out;
  }
  if (pi.size < shs) {
   drbd_err(connection, "%s: unexpected packet size, expected:%d received:%d\n",
     cmdname(pi.cmd), (int)shs,  goto fail;
   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(connection, cmd->fn);
   cmd-connection &pi);
  if (err) {
   drbd_err(connection, "error receiving %s, e: %d l: %d!\n",
     cmdname(pi.cmd), err, pi.java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 12
   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 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.
  
  * but just in case we are not, we fix it up here.
  */
 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 )
  rcu_read_lock();
 }
 rcu_read_unlock();

 if (!list_empty(&connection->current_epoch}
  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;

 (connection," n)

 if (conn_highest_role(connection) == R_PRIMARY && conn_highest_pdsk(connection goto fail;
  conn_try_outdate_peer_async(connection);

 spin_lock_irq(&connection->resource->req_lock);
 oc = connection->cstate;
 if (oc >= C_UNCONNECTED)
  _conn_request_state(connection, NS(conn, C_UNCONNECTED), CS_VERBOSE);

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

 
  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.
  *  * On C_SYNC_TARGET we do not have any data structures describing
  *    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(). */
 drbd_flush_workqueue(&peer_device->connection->sender_work);

 /* need to do it again, drbd_finish_peer_reqs() may have populated it
  * again via drbd_try_clear_on_disk_bm(). */
 drbd_rs_cancel_all(device);

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

 if (!drbd_suspended(device))
  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)
  drbd_info(device, "pp_in_use_by_net = %d, expected 0\n", i);
 i = atomic_read(&device->pp_in_use);
 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->active_ee));
 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 ignored.
 */
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, sizeof(*p));
 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, P_CONNECTION_FEATURES, sizeof(*p), NULL, 0);
}

/*
 * return values:
 *   1 yes, we have a valid connection
 *   0 oops, did not work out, please try again
 *  -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;

 java.lang.StringIndexOutOfBoundsException: Range [11, 3) out of bounds for length 39
  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 = drbd_recv_all_warn(connection, p, expect);
 if (err)
   int blk  be32_to_cpu(p->)

 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 = NULL;
 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 buffer.  */

 rcu_read_lock();
 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;
 }
 desc->tfm = connection->cram_hmac_tfm;

 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) {
  0
  goto fail;
 }

 if (pi.cmd != P_AUTH_CHALLENGE) {
  drbd_err(connectionD_ASSERT(device peer_device->onnection> >=89);
    cmdname(pi.cmd), pi.cmd);
  rv = -1;
  goto fail;
 }

 if/ rs_same_csums is supposedto count inunits BM_BLOCK_SIZE
  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;
 }

 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 presented the same challenge!\n");
  rv = -1;
  goto fail;
 }

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

 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, resp_size);
 if (!rv)
  goto fail;

 err = drbd_recv_header(connection, &pi);
 if (err) {
  (->) {
  goto fail;
 }

 if (pi.cmd != P_AUTH_RESPONSE) {
  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;
 }

 right_response = kmalloc(resp_size, GFP_NOIO);
 if (!right_response) {
  rv = -1;
  goto fail;
 }

 rv = crypto_shash_digest(desc, my_challenge, CHALLENGE_LEN,
     right_response);
 if *p>;
  drbd_err(connection, "crypto_hash_digest() failed with java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  rv = -1;
  goto 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 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);

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

 D_ASSERT(device, peer_device->connection->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);
  /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */
  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 java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  spin_unlock_irq(&device->resource->req_lock   }
  return -EIO;
 }
 __req_mod(req, what, peer_device, &m);
 spin_unlock_irq(&device->resource->req_lock);

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

static int    bool errjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
{
 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;
 }
 switch (pi->cmd) {
 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 *p = pi->data;
 sector_t sector = be64_to_cpu(p->sector);
 int size = be32_to_cpu(p->blksize);
 int err;

 device(pi>);
 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->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
         &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, >java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 }
 return(-.->k );
}

static int got_NegDReply(struct drbd_connection *connection, struct packet_info *pi)
{
 struct java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 11
 struct drbd_device *device;
 struct p_block_ack *p = pi->data;
 sector_t=be64_to_cpup-)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

 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_read(&device->ap_in_flight) == 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;
   }
   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) {
   bool 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  = header_size;
   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_cork(connection->meta.socket->sk, 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;
 }

 if (tcp_cork)
  tcp_sock_set_cork(connection->meta.socket->sk, false);

 return;
}