net/haproxy/patches/0001-BUG-MINOR-peers-peer-synchronization-issue-with-seve.patch

   1 From fa73e6b0d5f64eb8a6fd8a1706d7ec03293a943e Mon Sep 17 00:00:00 2001
   2 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20L=C3=A9caille?= <flecaille@haproxy.com>
   3 Date: Thu, 13 Jul 2017 09:07:09 +0200
   4 Subject: [PATCH 01/18] BUG/MINOR: peers: peer synchronization issue (with
   5  several peers sections).
   6
   7 When several stick-tables were configured with several peers sections,
   8 only a part of them could be synchronized: the ones attached to the last
   9 parsed 'peers' section. This was due to the fact that, at least, the peer I/O handler
  10 refered to the wrong peer section list, in fact always the same: the last one parsed.
  11
  12 The fact that the global peer section list was named "struct peers *peers"
  13 lead to this issue. This variable name is dangerous ;).
  14
  15 So this patch renames global 'peers' variable to 'cfg_peers' to ensure that
  16 no such wrong references are still in use, then all the functions wich used
  17 old 'peers' variable have been modified to refer to the correct peer list.
  18
  19 Must be backported to 1.6 and 1.7.
  20 (cherry picked from commit ed2b4a6b793d062000518e51ed71e014c649c313)
  21
  22 Signed-off-by: Willy Tarreau <w@1wt.eu>
  23 ---
  24  include/types/peers.h |  2 +-
  25  src/cfgparse.c        | 18 +++++++++---------
  26  src/haproxy.c         | 10 +++++-----
  27  src/peers.c           | 40 ++++++++++++++++++++--------------------
  28  src/proxy.c           |  6 +++---
  29  5 files changed, 38 insertions(+), 38 deletions(-)
  30
  31 diff --git a/include/types/peers.h b/include/types/peers.h
  32 index 105dffb0..a77a0942 100644
  33 --- a/include/types/peers.h
  34 +++ b/include/types/peers.h
  35 @@ -91,7 +91,7 @@ struct peers {
  36  };
  37
  38
  39 -extern struct peers *peers;
  40 +extern struct peers *cfg_peers;
  41
  42  #endif /* _TYPES_PEERS_H */
  43
  44 diff --git a/src/cfgparse.c b/src/cfgparse.c
  45 index 8c0906bf..1b53006b 100644
  46 --- a/src/cfgparse.c
  47 +++ b/src/cfgparse.c
  48 @@ -2124,7 +2124,7 @@ int cfg_parse_peers(const char *file, int linenum, char **args, int kwm)
  49                         goto out;
  50                 }
  51
  52 -               for (curpeers = peers; curpeers != NULL; curpeers = curpeers->next) {
  53 +               for (curpeers = cfg_peers; curpeers != NULL; curpeers = curpeers->next) {
  54                         /*
  55                          * If there are two proxies with the same name only following
  56                          * combinations are allowed:
  57 @@ -2142,8 +2142,8 @@ int cfg_parse_peers(const char *file, int linenum, char **args, int kwm)
  58                         goto out;
  59                 }
  60
  61 -               curpeers->next = peers;
  62 -               peers = curpeers;
  63 +               curpeers->next = cfg_peers;
  64 +               cfg_peers = curpeers;
  65                 curpeers->conf.file = strdup(file);
  66                 curpeers->conf.line = linenum;
  67                 curpeers->last_change = now.tv_sec;
  68 @@ -2223,7 +2223,7 @@ int cfg_parse_peers(const char *file, int linenum, char **args, int kwm)
  69                 if (strcmp(newpeer->id, localpeer) == 0) {
  70                         /* Current is local peer, it define a frontend */
  71                         newpeer->local = 1;
  72 -                       peers->local = newpeer;
  73 +                       cfg_peers->local = newpeer;
  74
  75                         if (!curpeers->peers_fe) {
  76                                 if ((curpeers->peers_fe  = calloc(1, sizeof(struct proxy))) == NULL) {
  77 @@ -8189,9 +8189,9 @@ int check_config_validity()
  78                 }
  79
  80                 if (curproxy->table.peers.name) {
  81 -                       struct peers *curpeers = peers;
  82 +                       struct peers *curpeers;
  83
  84 -                       for (curpeers = peers; curpeers; curpeers = curpeers->next) {
  85 +                       for (curpeers = cfg_peers; curpeers; curpeers = curpeers->next) {
  86                                 if (strcmp(curpeers->id, curproxy->table.peers.name) == 0) {
  87                                         free((void *)curproxy->table.peers.name);
  88                                         curproxy->table.peers.p = curpeers;
  89 @@ -9279,15 +9279,15 @@ out_uri_auth_compat:
  90                 if (curproxy->table.peers.p)
  91                         curproxy->table.peers.p->peers_fe->bind_proc |= curproxy->bind_proc;
  92
  93 -       if (peers) {
  94 -               struct peers *curpeers = peers, **last;
  95 +       if (cfg_peers) {
  96 +               struct peers *curpeers = cfg_peers, **last;
  97                 struct peer *p, *pb;
  98
  99                 /* Remove all peers sections which don't have a valid listener,
 100                  * which are not used by any table, or which are bound to more
 101                  * than one process.
 102                  */
 103 -               last = &peers;
 104 +               last = &cfg_peers;
 105                 while (*last) {
 106                         curpeers = *last;
 107
 108 diff --git a/src/haproxy.c b/src/haproxy.c
 109 index 6d09aed4..25cea0cd 100644
 110 --- a/src/haproxy.c
 111 +++ b/src/haproxy.c
 112 @@ -988,7 +988,7 @@ void init(int argc, char **argv)
 113                 struct peers *pr;
 114                 struct proxy *px;
 115
 116 -               for (pr = peers; pr; pr = pr->next)
 117 +               for (pr = cfg_peers; pr; pr = pr->next)
 118                         if (pr->peers_fe)
 119                                 break;
 120
 121 @@ -1217,11 +1217,11 @@ void init(int argc, char **argv)
 122         if (global.stats_fe)
 123                 global.maxsock += global.stats_fe->maxconn;
 124
 125 -       if (peers) {
 126 +       if (cfg_peers) {
 127                 /* peers also need to bypass global maxconn */
 128 -               struct peers *p = peers;
 129 +               struct peers *p = cfg_peers;
 130
 131 -               for (p = peers; p; p = p->next)
 132 +               for (p = cfg_peers; p; p = p->next)
 133                         if (p->peers_fe)
 134                                 global.maxsock += p->peers_fe->maxconn;
 135         }
 136 @@ -2067,7 +2067,7 @@ int main(int argc, char **argv)
 137                 }
 138
 139                 /* we might have to unbind some peers sections from some processes */
 140 -               for (curpeers = peers; curpeers; curpeers = curpeers->next) {
 141 +               for (curpeers = cfg_peers; curpeers; curpeers = curpeers->next) {
 142                         if (!curpeers->peers_fe)
 143                                 continue;
 144
 145 diff --git a/src/peers.c b/src/peers.c
 146 index 543c84c1..5b8a287a 100644
 147 --- a/src/peers.c
 148 +++ b/src/peers.c
 149 @@ -171,7 +171,7 @@ enum {
 150  #define PEER_MINOR_VER        1
 151  #define PEER_DWNGRD_MINOR_VER 0
 152
 153 -struct peers *peers = NULL;
 154 +struct peers *cfg_peers = NULL;
 155  static void peer_session_forceshutdown(struct appctx *appctx);
 156
 157  /* This function encode an uint64 to 'dynamic' length format.
 158 @@ -727,19 +727,19 @@ switchstate:
 159                                 /* if current peer is local */
 160                                  if (curpeer->local) {
 161                                          /* if current host need resyncfrom local and no process assined  */
 162 -                                        if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL &&
 163 -                                            !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
 164 +                                        if ((curpeers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL &&
 165 +                                            !(curpeers->flags & PEERS_F_RESYNC_ASSIGN)) {
 166                                                  /* assign local peer for a lesson, consider lesson already requested */
 167                                                  curpeer->flags |= PEER_F_LEARN_ASSIGN;
 168 -                                                peers->flags |= (PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
 169 +                                                curpeers->flags |= (PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
 170                                          }
 171
 172                                  }
 173 -                                else if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
 174 -                                         !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
 175 +                                else if ((curpeers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
 176 +                                         !(curpeers->flags & PEERS_F_RESYNC_ASSIGN)) {
 177                                          /* assign peer for a lesson  */
 178                                          curpeer->flags |= PEER_F_LEARN_ASSIGN;
 179 -                                        peers->flags |= PEERS_F_RESYNC_ASSIGN;
 180 +                                        curpeers->flags |= PEERS_F_RESYNC_ASSIGN;
 181                                  }
 182
 183
 184 @@ -807,7 +807,7 @@ switchstate:
 185                                 curpeer->statuscode = atoi(trash.str);
 186
 187                                 /* Awake main task */
 188 -                               task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
 189 +                               task_wakeup(curpeers->sync_task, TASK_WOKEN_MSG);
 190
 191                                 /* If status code is success */
 192                                 if (curpeer->statuscode == PEER_SESS_SC_SUCCESSCODE) {
 193 @@ -830,14 +830,14 @@ switchstate:
 194                                                  curpeer->flags |= PEER_F_TEACH_PROCESS;
 195
 196                                          }
 197 -                                        else if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
 198 -                                                    !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
 199 +                                        else if ((curpeers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
 200 +                                                    !(curpeers->flags & PEERS_F_RESYNC_ASSIGN)) {
 201                                                  /* If peer is remote and resync from remote is needed,
 202                                                     and no peer currently assigned */
 203
 204                                                  /* assign peer for a lesson */
 205                                                  curpeer->flags |= PEER_F_LEARN_ASSIGN;
 206 -                                               peers->flags |= PEERS_F_RESYNC_ASSIGN;
 207 +                                               curpeers->flags |= PEERS_F_RESYNC_ASSIGN;
 208                                         }
 209
 210                                 }
 211 @@ -950,8 +950,8 @@ switchstate:
 212
 213                                                 if (curpeer->flags & PEER_F_LEARN_ASSIGN) {
 214                                                         curpeer->flags &= ~PEER_F_LEARN_ASSIGN;
 215 -                                                       peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
 216 -                                                       peers->flags |= (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE);
 217 +                                                       curpeers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
 218 +                                                       curpeers->flags |= (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE);
 219                                                 }
 220                                                 curpeer->confirm++;
 221                                         }
 222 @@ -959,11 +959,11 @@ switchstate:
 223
 224                                                 if (curpeer->flags & PEER_F_LEARN_ASSIGN) {
 225                                                         curpeer->flags &= ~PEER_F_LEARN_ASSIGN;
 226 -                                                       peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
 227 +                                                       curpeers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
 228
 229                                                         curpeer->flags |= PEER_F_LEARN_NOTUP2DATE;
 230 -                                                       peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(5000));
 231 -                                                       task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
 232 +                                                       curpeers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(5000));
 233 +                                                       task_wakeup(curpeers->sync_task, TASK_WOKEN_MSG);
 234                                                 }
 235                                                 curpeer->confirm++;
 236                                         }
 237 @@ -1334,8 +1334,8 @@ incomplete:
 238
 239                                 /* Need to request a resync */
 240                                  if ((curpeer->flags & PEER_F_LEARN_ASSIGN) &&
 241 -                                        (peers->flags & PEERS_F_RESYNC_ASSIGN) &&
 242 -                                        !(peers->flags & PEERS_F_RESYNC_PROCESS)) {
 243 +                                        (curpeers->flags & PEERS_F_RESYNC_ASSIGN) &&
 244 +                                        !(curpeers->flags & PEERS_F_RESYNC_PROCESS)) {
 245                                         unsigned char msg[2];
 246
 247                                          /* Current peer was elected to request a resync */
 248 @@ -1351,7 +1351,7 @@ incomplete:
 249                                                  appctx->st0 = PEER_SESS_ST_END;
 250                                                  goto switchstate;
 251                                          }
 252 -                                        peers->flags |= PEERS_F_RESYNC_PROCESS;
 253 +                                        curpeers->flags |= PEERS_F_RESYNC_PROCESS;
 254                                  }
 255
 256                                 /* Nothing to read, now we start to write */
 257 @@ -1624,7 +1624,7 @@ incomplete:
 258
 259                                          /* Current peer was elected to request a resync */
 260                                         msg[0] = PEER_MSG_CLASS_CONTROL;
 261 -                                       msg[1] = ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FINISHED) ? PEER_MSG_CTRL_RESYNCFINISHED : PEER_MSG_CTRL_RESYNCPARTIAL;
 262 +                                       msg[1] = ((curpeers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FINISHED) ? PEER_MSG_CTRL_RESYNCFINISHED : PEER_MSG_CTRL_RESYNCPARTIAL;
 263                                         /* process final lesson message */
 264                                         repl = bi_putblk(si_ic(si), (char *)msg, sizeof(msg));
 265                                         if (repl <= 0) {
 266 diff --git a/src/proxy.c b/src/proxy.c
 267 index 78120d9b..bedc7ae0 100644
 268 --- a/src/proxy.c
 269 +++ b/src/proxy.c
 270 @@ -1007,7 +1007,7 @@ void soft_stop(void)
 271                 p = p->next;
 272         }
 273
 274 -       prs = peers;
 275 +       prs = cfg_peers;
 276         while (prs) {
 277                 if (prs->peers_fe)
 278                         stop_proxy(prs->peers_fe);
 279 @@ -1142,7 +1142,7 @@ void pause_proxies(void)
 280                 p = p->next;
 281         }
 282
 283 -       prs = peers;
 284 +       prs = cfg_peers;
 285         while (prs) {
 286                 if (prs->peers_fe)
 287                         err |= !pause_proxy(prs->peers_fe);
 288 @@ -1176,7 +1176,7 @@ void resume_proxies(void)
 289                 p = p->next;
 290         }
 291
 292 -       prs = peers;
 293 +       prs = cfg_peers;
 294         while (prs) {
 295                 if (prs->peers_fe)
 296                         err |= !resume_proxy(prs->peers_fe);
 297 --
 298 2.13.0
 299