← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to net/netfilter/ipvs/ip_vs_sync.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
net/netfilter/ipvs/ip_vs_sync.c
5
5
 *              high-performance and highly available server based on a
6
6
 *              cluster of servers.
7
7
 *
 
8
 * Version 1,   is capable of handling both version 0 and 1 messages.
 
9
 *              Version 0 is the plain old format.
 
10
 *              Note Version 0 receivers will just drop Ver 1 messages.
 
11
 *              Version 1 is capable of handle IPv6, Persistence data,
 
12
 *              time-outs, and firewall marks.
 
13
 *              In ver.1 "ip_vs_sync_conn_options" will be sent in netw. order.
 
14
 *              Ver. 0 can be turned on by sysctl -w net.ipv4.vs.sync_version=0
 
15
 *
 
16
 * Definitions  Message: is a complete datagram
 
17
 *              Sync_conn: is a part of a Message
 
18
 *              Param Data is an option to a Sync_conn.
 
19
 *
8
20
 * Authors:     Wensong Zhang <wensong@linuxvirtualserver.org>
9
21
 *
10
22
 * ip_vs_sync:  sync connection info from master load balancer to backups
15
27
 *      Alexandre Cassen        :       Added SyncID support for incoming sync
16
28
 *                                      messages filtering.
17
29
 *      Justin Ossevoort        :       Fix endian problem on sync message size.
 
30
 *      Hans Schillstrom        :       Added Version 1: i.e. IPv6,
 
31
 *                                      Persistence support, fwmark and time-out.
18
32
 */
19
33
 
20
34
#define KMSG_COMPONENT "IPVS"
35
49
#include <linux/wait.h>
36
50
#include <linux/kernel.h>
37
51
 
 
52
#include <asm/unaligned.h>              /* Used for ntoh_seq and hton_seq */
 
53
 
38
54
#include <net/ip.h>
39
55
#include <net/sock.h>
40
56
 
43
59
#define IP_VS_SYNC_GROUP 0xe0000051    /* multicast addr - 224.0.0.81 */
44
60
#define IP_VS_SYNC_PORT  8848          /* multicast port */
45
61
 
 
62
#define SYNC_PROTO_VER  1               /* Protocol version in header */
46
63
 
47
64
/*
48
65
 *      IPVS sync connection entry
 
66
 *      Version 0, i.e. original version.
49
67
 */
50
 
struct ip_vs_sync_conn {
 
68
struct ip_vs_sync_conn_v0 {
51
69
        __u8                    reserved;
52
70
 
53
71
        /* Protocol, addresses and port numbers */
71
89
        struct ip_vs_seq        out_seq;        /* outgoing seq. struct */
72
90
};
73
91
 
 
92
/*
 
93
     Sync Connection format (sync_conn)
 
94
 
 
95
       0                   1                   2                   3
 
96
       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 
97
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
98
      |    Type       |    Protocol   | Ver.  |        Size           |
 
99
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
100
      |                             Flags                             |
 
101
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
102
      |            State              |         cport                 |
 
103
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
104
      |            vport              |         dport                 |
 
105
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
106
      |                             fwmark                            |
 
107
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
108
      |                             timeout  (in sec.)                |
 
109
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
110
      |                              ...                              |
 
111
      |                        IP-Addresses  (v4 or v6)               |
 
112
      |                              ...                              |
 
113
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
114
  Optional Parameters.
 
115
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
116
      | Param. Type    | Param. Length |   Param. data                |
 
117
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                               |
 
118
      |                              ...                              |
 
119
      |                               +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
120
      |                               | Param Type    | Param. Length |
 
121
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
122
      |                           Param  data                         |
 
123
      |         Last Param data should be padded for 32 bit alignment |
 
124
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
125
*/
 
126
 
 
127
/*
 
128
 *  Type 0, IPv4 sync connection format
 
129
 */
 
130
struct ip_vs_sync_v4 {
 
131
        __u8                    type;
 
132
        __u8                    protocol;       /* Which protocol (TCP/UDP) */
 
133
        __be16                  ver_size;       /* Version msb 4 bits */
 
134
        /* Flags and state transition */
 
135
        __be32                  flags;          /* status flags */
 
136
        __be16                  state;          /* state info   */
 
137
        /* Protocol, addresses and port numbers */
 
138
        __be16                  cport;
 
139
        __be16                  vport;
 
140
        __be16                  dport;
 
141
        __be32                  fwmark;         /* Firewall mark from skb */
 
142
        __be32                  timeout;        /* cp timeout */
 
143
        __be32                  caddr;          /* client address */
 
144
        __be32                  vaddr;          /* virtual address */
 
145
        __be32                  daddr;          /* destination address */
 
146
        /* The sequence options start here */
 
147
        /* PE data padded to 32bit alignment after seq. options */
 
148
};
 
149
/*
 
150
 * Type 2 messages IPv6
 
151
 */
 
152
struct ip_vs_sync_v6 {
 
153
        __u8                    type;
 
154
        __u8                    protocol;       /* Which protocol (TCP/UDP) */
 
155
        __be16                  ver_size;       /* Version msb 4 bits */
 
156
        /* Flags and state transition */
 
157
        __be32                  flags;          /* status flags */
 
158
        __be16                  state;          /* state info   */
 
159
        /* Protocol, addresses and port numbers */
 
160
        __be16                  cport;
 
161
        __be16                  vport;
 
162
        __be16                  dport;
 
163
        __be32                  fwmark;         /* Firewall mark from skb */
 
164
        __be32                  timeout;        /* cp timeout */
 
165
        struct in6_addr         caddr;          /* client address */
 
166
        struct in6_addr         vaddr;          /* virtual address */
 
167
        struct in6_addr         daddr;          /* destination address */
 
168
        /* The sequence options start here */
 
169
        /* PE data padded to 32bit alignment after seq. options */
 
170
};
 
171
 
 
172
union ip_vs_sync_conn {
 
173
        struct ip_vs_sync_v4    v4;
 
174
        struct ip_vs_sync_v6    v6;
 
175
};
 
176
 
 
177
/* Bits in Type field in above */
 
178
#define STYPE_INET6             0
 
179
#define STYPE_F_INET6           (1 << STYPE_INET6)
 
180
 
 
181
#define SVER_SHIFT              12              /* Shift to get version */
 
182
#define SVER_MASK               0x0fff          /* Mask to strip version */
 
183
 
 
184
#define IPVS_OPT_SEQ_DATA       1
 
185
#define IPVS_OPT_PE_DATA        2
 
186
#define IPVS_OPT_PE_NAME        3
 
187
#define IPVS_OPT_PARAM          7
 
188
 
 
189
#define IPVS_OPT_F_SEQ_DATA     (1 << (IPVS_OPT_SEQ_DATA-1))
 
190
#define IPVS_OPT_F_PE_DATA      (1 << (IPVS_OPT_PE_DATA-1))
 
191
#define IPVS_OPT_F_PE_NAME      (1 << (IPVS_OPT_PE_NAME-1))
 
192
#define IPVS_OPT_F_PARAM        (1 << (IPVS_OPT_PARAM-1))
 
193
 
74
194
struct ip_vs_sync_thread_data {
 
195
        struct net *net;
75
196
        struct socket *sock;
76
197
        char *buf;
77
198
};
78
199
 
79
 
#define SIMPLE_CONN_SIZE  (sizeof(struct ip_vs_sync_conn))
 
200
/* Version 0 definition of packet sizes */
 
201
#define SIMPLE_CONN_SIZE  (sizeof(struct ip_vs_sync_conn_v0))
80
202
#define FULL_CONN_SIZE  \
81
 
(sizeof(struct ip_vs_sync_conn) + sizeof(struct ip_vs_sync_conn_options))
 
203
(sizeof(struct ip_vs_sync_conn_v0) + sizeof(struct ip_vs_sync_conn_options))
82
204
 
83
205
 
84
206
/*
85
 
  The master mulitcasts messages to the backup load balancers in the
86
 
  following format.
87
 
 
 
207
  The master mulitcasts messages (Datagrams) to the backup load balancers
 
208
  in the following format.
 
209
 
 
210
 Version 1:
 
211
  Note, first byte should be Zero, so ver 0 receivers will drop the packet.
 
212
 
 
213
       0                   1                   2                   3
 
214
       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 
215
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
216
      |      0        |    SyncID     |            Size               |
 
217
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
218
      |  Count Conns  |    Version    |    Reserved, set to Zero      |
 
219
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
220
      |                                                               |
 
221
      |                    IPVS Sync Connection (1)                   |
 
222
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
223
      |                            .                                  |
 
224
      ~                            .                                  ~
 
225
      |                            .                                  |
 
226
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
227
      |                                                               |
 
228
      |                    IPVS Sync Connection (n)                   |
 
229
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
230
 
 
231
 Version 0 Header
88
232
       0                   1                   2                   3
89
233
       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
90
234
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
91
235
      |  Count Conns  |    SyncID     |            Size               |
92
236
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
93
 
      |                                                               |
94
237
      |                    IPVS Sync Connection (1)                   |
95
 
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
96
 
      |                            .                                  |
97
 
      |                            .                                  |
98
 
      |                            .                                  |
99
 
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
100
 
      |                                                               |
101
 
      |                    IPVS Sync Connection (n)                   |
102
 
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
103
238
*/
104
239
 
105
240
#define SYNC_MESG_HEADER_LEN    4
106
241
#define MAX_CONNS_PER_SYNCBUFF  255 /* nr_conns in ip_vs_sync_mesg is 8 bit */
107
242
 
108
 
struct ip_vs_sync_mesg {
 
243
/* Version 0 header */
 
244
struct ip_vs_sync_mesg_v0 {
109
245
        __u8                    nr_conns;
110
246
        __u8                    syncid;
111
247
        __u16                   size;
113
249
        /* ip_vs_sync_conn entries start here */
114
250
};
115
251
 
116
 
/* the maximum length of sync (sending/receiving) message */
117
 
static int sync_send_mesg_maxlen;
118
 
static int sync_recv_mesg_maxlen;
 
252
/* Version 1 header */
 
253
struct ip_vs_sync_mesg {
 
254
        __u8                    reserved;       /* must be zero */
 
255
        __u8                    syncid;
 
256
        __u16                   size;
 
257
        __u8                    nr_conns;
 
258
        __s8                    version;        /* SYNC_PROTO_VER  */
 
259
        __u16                   spare;
 
260
        /* ip_vs_sync_conn entries start here */
 
261
};
119
262
 
120
263
struct ip_vs_sync_buff {
121
264
        struct list_head        list;
127
270
        unsigned char           *end;
128
271
};
129
272
 
130
 
 
131
 
/* the sync_buff list head and the lock */
132
 
static LIST_HEAD(ip_vs_sync_queue);
133
 
static DEFINE_SPINLOCK(ip_vs_sync_lock);
134
 
 
135
 
/* current sync_buff for accepting new conn entries */
136
 
static struct ip_vs_sync_buff   *curr_sb = NULL;
137
 
static DEFINE_SPINLOCK(curr_sb_lock);
138
 
 
139
 
/* ipvs sync daemon state */
140
 
volatile int ip_vs_sync_state = IP_VS_STATE_NONE;
141
 
volatile int ip_vs_master_syncid = 0;
142
 
volatile int ip_vs_backup_syncid = 0;
143
 
 
144
 
/* multicast interface name */
145
 
char ip_vs_master_mcast_ifn[IP_VS_IFNAME_MAXLEN];
146
 
char ip_vs_backup_mcast_ifn[IP_VS_IFNAME_MAXLEN];
147
 
 
148
 
/* sync daemon tasks */
149
 
static struct task_struct *sync_master_thread;
150
 
static struct task_struct *sync_backup_thread;
151
 
 
152
273
/* multicast addr */
153
274
static struct sockaddr_in mcast_addr = {
154
275
        .sin_family             = AF_INET,
156
277
        .sin_addr.s_addr        = cpu_to_be32(IP_VS_SYNC_GROUP),
157
278
};
158
279
 
159
 
 
160
 
static inline struct ip_vs_sync_buff *sb_dequeue(void)
 
280
/*
 
281
 * Copy of struct ip_vs_seq
 
282
 * From unaligned network order to aligned host order
 
283
 */
 
284
static void ntoh_seq(struct ip_vs_seq *no, struct ip_vs_seq *ho)
 
285
{
 
286
        ho->init_seq       = get_unaligned_be32(&no->init_seq);
 
287
        ho->delta          = get_unaligned_be32(&no->delta);
 
288
        ho->previous_delta = get_unaligned_be32(&no->previous_delta);
 
289
}
 
290
 
 
291
/*
 
292
 * Copy of struct ip_vs_seq
 
293
 * From Aligned host order to unaligned network order
 
294
 */
 
295
static void hton_seq(struct ip_vs_seq *ho, struct ip_vs_seq *no)
 
296
{
 
297
        put_unaligned_be32(ho->init_seq, &no->init_seq);
 
298
        put_unaligned_be32(ho->delta, &no->delta);
 
299
        put_unaligned_be32(ho->previous_delta, &no->previous_delta);
 
300
}
 
301
 
 
302
static inline struct ip_vs_sync_buff *sb_dequeue(struct netns_ipvs *ipvs)
161
303
{
162
304
        struct ip_vs_sync_buff *sb;
163
305
 
164
 
        spin_lock_bh(&ip_vs_sync_lock);
165
 
        if (list_empty(&ip_vs_sync_queue)) {
 
306
        spin_lock_bh(&ipvs->sync_lock);
 
307
        if (list_empty(&ipvs->sync_queue)) {
166
308
                sb = NULL;
167
309
        } else {
168
 
                sb = list_entry(ip_vs_sync_queue.next,
 
310
                sb = list_entry(ipvs->sync_queue.next,
169
311
                                struct ip_vs_sync_buff,
170
312
                                list);
171
313
                list_del(&sb->list);
172
314
        }
173
 
        spin_unlock_bh(&ip_vs_sync_lock);
 
315
        spin_unlock_bh(&ipvs->sync_lock);
174
316
 
175
317
        return sb;
176
318
}
177
319
 
178
 
static inline struct ip_vs_sync_buff * ip_vs_sync_buff_create(void)
 
320
/*
 
321
 * Create a new sync buffer for Version 1 proto.
 
322
 */
 
323
static inline struct ip_vs_sync_buff *
 
324
ip_vs_sync_buff_create(struct netns_ipvs *ipvs)
179
325
{
180
326
        struct ip_vs_sync_buff *sb;
181
327
 
182
328
        if (!(sb=kmalloc(sizeof(struct ip_vs_sync_buff), GFP_ATOMIC)))
183
329
                return NULL;
184
330
 
185
 
        if (!(sb->mesg=kmalloc(sync_send_mesg_maxlen, GFP_ATOMIC))) {
 
331
        sb->mesg = kmalloc(ipvs->send_mesg_maxlen, GFP_ATOMIC);
 
332
        if (!sb->mesg) {
186
333
                kfree(sb);
187
334
                return NULL;
188
335
        }
 
336
        sb->mesg->reserved = 0;  /* old nr_conns i.e. must be zeo now */
 
337
        sb->mesg->version = SYNC_PROTO_VER;
 
338
        sb->mesg->syncid = ipvs->master_syncid;
 
339
        sb->mesg->size = sizeof(struct ip_vs_sync_mesg);
189
340
        sb->mesg->nr_conns = 0;
190
 
        sb->mesg->syncid = ip_vs_master_syncid;
191
 
        sb->mesg->size = 4;
192
 
        sb->head = (unsigned char *)sb->mesg + 4;
193
 
        sb->end = (unsigned char *)sb->mesg + sync_send_mesg_maxlen;
 
341
        sb->mesg->spare = 0;
 
342
        sb->head = (unsigned char *)sb->mesg + sizeof(struct ip_vs_sync_mesg);
 
343
        sb->end = (unsigned char *)sb->mesg + ipvs->send_mesg_maxlen;
 
344
 
194
345
        sb->firstuse = jiffies;
195
346
        return sb;
196
347
}
201
352
        kfree(sb);
202
353
}
203
354
 
204
 
static inline void sb_queue_tail(struct ip_vs_sync_buff *sb)
 
355
static inline void sb_queue_tail(struct netns_ipvs *ipvs)
205
356
{
206
 
        spin_lock(&ip_vs_sync_lock);
207
 
        if (ip_vs_sync_state & IP_VS_STATE_MASTER)
208
 
                list_add_tail(&sb->list, &ip_vs_sync_queue);
 
357
        struct ip_vs_sync_buff *sb = ipvs->sync_buff;
 
358
 
 
359
        spin_lock(&ipvs->sync_lock);
 
360
        if (ipvs->sync_state & IP_VS_STATE_MASTER)
 
361
                list_add_tail(&sb->list, &ipvs->sync_queue);
209
362
        else
210
363
                ip_vs_sync_buff_release(sb);
211
 
        spin_unlock(&ip_vs_sync_lock);
 
364
        spin_unlock(&ipvs->sync_lock);
212
365
}
213
366
 
214
367
/*
216
369
 *      than the specified time or the specified time is zero.
217
370
 */
218
371
static inline struct ip_vs_sync_buff *
219
 
get_curr_sync_buff(unsigned long time)
 
372
get_curr_sync_buff(struct netns_ipvs *ipvs, unsigned long time)
220
373
{
221
374
        struct ip_vs_sync_buff *sb;
222
375
 
223
 
        spin_lock_bh(&curr_sb_lock);
224
 
        if (curr_sb && (time == 0 ||
225
 
                        time_before(jiffies - curr_sb->firstuse, time))) {
226
 
                sb = curr_sb;
227
 
                curr_sb = NULL;
 
376
        spin_lock_bh(&ipvs->sync_buff_lock);
 
377
        if (ipvs->sync_buff &&
 
378
            time_after_eq(jiffies - ipvs->sync_buff->firstuse, time)) {
 
379
                sb = ipvs->sync_buff;
 
380
                ipvs->sync_buff = NULL;
228
381
        } else
229
382
                sb = NULL;
230
 
        spin_unlock_bh(&curr_sb_lock);
231
 
        return sb;
232
 
}
233
 
 
234
 
 
235
 
/*
 
383
        spin_unlock_bh(&ipvs->sync_buff_lock);
 
384
        return sb;
 
385
}
 
386
 
 
387
/*
 
388
 * Switch mode from sending version 0 or 1
 
389
 *  - must handle sync_buf
 
390
 */
 
391
void ip_vs_sync_switch_mode(struct net *net, int mode)
 
392
{
 
393
        struct netns_ipvs *ipvs = net_ipvs(net);
 
394
 
 
395
        if (!(ipvs->sync_state & IP_VS_STATE_MASTER))
 
396
                return;
 
397
        if (mode == sysctl_sync_ver(ipvs) || !ipvs->sync_buff)
 
398
                return;
 
399
 
 
400
        spin_lock_bh(&ipvs->sync_buff_lock);
 
401
        /* Buffer empty ? then let buf_create do the job  */
 
402
        if (ipvs->sync_buff->mesg->size <=  sizeof(struct ip_vs_sync_mesg)) {
 
403
                kfree(ipvs->sync_buff);
 
404
                ipvs->sync_buff = NULL;
 
405
        } else {
 
406
                spin_lock_bh(&ipvs->sync_lock);
 
407
                if (ipvs->sync_state & IP_VS_STATE_MASTER)
 
408
                        list_add_tail(&ipvs->sync_buff->list,
 
409
                                      &ipvs->sync_queue);
 
410
                else
 
411
                        ip_vs_sync_buff_release(ipvs->sync_buff);
 
412
                spin_unlock_bh(&ipvs->sync_lock);
 
413
        }
 
414
        spin_unlock_bh(&ipvs->sync_buff_lock);
 
415
}
 
416
 
 
417
/*
 
418
 * Create a new sync buffer for Version 0 proto.
 
419
 */
 
420
static inline struct ip_vs_sync_buff *
 
421
ip_vs_sync_buff_create_v0(struct netns_ipvs *ipvs)
 
422
{
 
423
        struct ip_vs_sync_buff *sb;
 
424
        struct ip_vs_sync_mesg_v0 *mesg;
 
425
 
 
426
        if (!(sb=kmalloc(sizeof(struct ip_vs_sync_buff), GFP_ATOMIC)))
 
427
                return NULL;
 
428
 
 
429
        sb->mesg = kmalloc(ipvs->send_mesg_maxlen, GFP_ATOMIC);
 
430
        if (!sb->mesg) {
 
431
                kfree(sb);
 
432
                return NULL;
 
433
        }
 
434
        mesg = (struct ip_vs_sync_mesg_v0 *)sb->mesg;
 
435
        mesg->nr_conns = 0;
 
436
        mesg->syncid = ipvs->master_syncid;
 
437
        mesg->size = sizeof(struct ip_vs_sync_mesg_v0);
 
438
        sb->head = (unsigned char *)mesg + sizeof(struct ip_vs_sync_mesg_v0);
 
439
        sb->end = (unsigned char *)mesg + ipvs->send_mesg_maxlen;
 
440
        sb->firstuse = jiffies;
 
441
        return sb;
 
442
}
 
443
 
 
444
/*
 
445
 *      Version 0 , could be switched in by sys_ctl.
236
446
 *      Add an ip_vs_conn information into the current sync_buff.
237
 
 *      Called by ip_vs_in.
238
447
 */
239
 
void ip_vs_sync_conn(struct ip_vs_conn *cp)
 
448
void ip_vs_sync_conn_v0(struct net *net, struct ip_vs_conn *cp)
240
449
{
241
 
        struct ip_vs_sync_mesg *m;
242
 
        struct ip_vs_sync_conn *s;
 
450
        struct netns_ipvs *ipvs = net_ipvs(net);
 
451
        struct ip_vs_sync_mesg_v0 *m;
 
452
        struct ip_vs_sync_conn_v0 *s;
243
453
        int len;
244
454
 
245
 
        spin_lock(&curr_sb_lock);
246
 
        if (!curr_sb) {
247
 
                if (!(curr_sb=ip_vs_sync_buff_create())) {
248
 
                        spin_unlock(&curr_sb_lock);
 
455
        if (unlikely(cp->af != AF_INET))
 
456
                return;
 
457
        /* Do not sync ONE PACKET */
 
458
        if (cp->flags & IP_VS_CONN_F_ONE_PACKET)
 
459
                return;
 
460
 
 
461
        spin_lock(&ipvs->sync_buff_lock);
 
462
        if (!ipvs->sync_buff) {
 
463
                ipvs->sync_buff =
 
464
                        ip_vs_sync_buff_create_v0(ipvs);
 
465
                if (!ipvs->sync_buff) {
 
466
                        spin_unlock(&ipvs->sync_buff_lock);
249
467
                        pr_err("ip_vs_sync_buff_create failed.\n");
250
468
                        return;
251
469
                }
253
471
 
254
472
        len = (cp->flags & IP_VS_CONN_F_SEQ_MASK) ? FULL_CONN_SIZE :
255
473
                SIMPLE_CONN_SIZE;
256
 
        m = curr_sb->mesg;
257
 
        s = (struct ip_vs_sync_conn *)curr_sb->head;
 
474
        m = (struct ip_vs_sync_mesg_v0 *)ipvs->sync_buff->mesg;
 
475
        s = (struct ip_vs_sync_conn_v0 *)ipvs->sync_buff->head;
258
476
 
259
477
        /* copy members */
 
478
        s->reserved = 0;
260
479
        s->protocol = cp->protocol;
261
480
        s->cport = cp->cport;
262
481
        s->vport = cp->vport;
274
493
 
275
494
        m->nr_conns++;
276
495
        m->size += len;
277
 
        curr_sb->head += len;
 
496
        ipvs->sync_buff->head += len;
278
497
 
279
498
        /* check if there is a space for next one */
280
 
        if (curr_sb->head+FULL_CONN_SIZE > curr_sb->end) {
281
 
                sb_queue_tail(curr_sb);
282
 
                curr_sb = NULL;
 
499
        if (ipvs->sync_buff->head + FULL_CONN_SIZE > ipvs->sync_buff->end) {
 
500
                sb_queue_tail(ipvs);
 
501
                ipvs->sync_buff = NULL;
283
502
        }
284
 
        spin_unlock(&curr_sb_lock);
 
503
        spin_unlock(&ipvs->sync_buff_lock);
285
504
 
286
505
        /* synchronize its controller if it has */
287
506
        if (cp->control)
288
 
                ip_vs_sync_conn(cp->control);
289
 
}
290
 
 
 
507
                ip_vs_sync_conn(net, cp->control);
 
508
}
 
509
 
 
510
/*
 
511
 *      Add an ip_vs_conn information into the current sync_buff.
 
512
 *      Called by ip_vs_in.
 
513
 *      Sending Version 1 messages
 
514
 */
 
515
void ip_vs_sync_conn(struct net *net, struct ip_vs_conn *cp)
 
516
{
 
517
        struct netns_ipvs *ipvs = net_ipvs(net);
 
518
        struct ip_vs_sync_mesg *m;
 
519
        union ip_vs_sync_conn *s;
 
520
        __u8 *p;
 
521
        unsigned int len, pe_name_len, pad;
 
522
 
 
523
        /* Handle old version of the protocol */
 
524
        if (sysctl_sync_ver(ipvs) == 0) {
 
525
                ip_vs_sync_conn_v0(net, cp);
 
526
                return;
 
527
        }
 
528
        /* Do not sync ONE PACKET */
 
529
        if (cp->flags & IP_VS_CONN_F_ONE_PACKET)
 
530
                goto control;
 
531
sloop:
 
532
        /* Sanity checks */
 
533
        pe_name_len = 0;
 
534
        if (cp->pe_data_len) {
 
535
                if (!cp->pe_data || !cp->dest) {
 
536
                        IP_VS_ERR_RL("SYNC, connection pe_data invalid\n");
 
537
                        return;
 
538
                }
 
539
                pe_name_len = strnlen(cp->pe->name, IP_VS_PENAME_MAXLEN);
 
540
        }
 
541
 
 
542
        spin_lock(&ipvs->sync_buff_lock);
 
543
 
 
544
#ifdef CONFIG_IP_VS_IPV6
 
545
        if (cp->af == AF_INET6)
 
546
                len = sizeof(struct ip_vs_sync_v6);
 
547
        else
 
548
#endif
 
549
                len = sizeof(struct ip_vs_sync_v4);
 
550
 
 
551
        if (cp->flags & IP_VS_CONN_F_SEQ_MASK)
 
552
                len += sizeof(struct ip_vs_sync_conn_options) + 2;
 
553
 
 
554
        if (cp->pe_data_len)
 
555
                len += cp->pe_data_len + 2;     /* + Param hdr field */
 
556
        if (pe_name_len)
 
557
                len += pe_name_len + 2;
 
558
 
 
559
        /* check if there is a space for this one  */
 
560
        pad = 0;
 
561
        if (ipvs->sync_buff) {
 
562
                pad = (4 - (size_t)ipvs->sync_buff->head) & 3;
 
563
                if (ipvs->sync_buff->head + len + pad > ipvs->sync_buff->end) {
 
564
                        sb_queue_tail(ipvs);
 
565
                        ipvs->sync_buff = NULL;
 
566
                        pad = 0;
 
567
                }
 
568
        }
 
569
 
 
570
        if (!ipvs->sync_buff) {
 
571
                ipvs->sync_buff = ip_vs_sync_buff_create(ipvs);
 
572
                if (!ipvs->sync_buff) {
 
573
                        spin_unlock(&ipvs->sync_buff_lock);
 
574
                        pr_err("ip_vs_sync_buff_create failed.\n");
 
575
                        return;
 
576
                }
 
577
        }
 
578
 
 
579
        m = ipvs->sync_buff->mesg;
 
580
        p = ipvs->sync_buff->head;
 
581
        ipvs->sync_buff->head += pad + len;
 
582
        m->size += pad + len;
 
583
        /* Add ev. padding from prev. sync_conn */
 
584
        while (pad--)
 
585
                *(p++) = 0;
 
586
 
 
587
        s = (union ip_vs_sync_conn *)p;
 
588
 
 
589
        /* Set message type  & copy members */
 
590
        s->v4.type = (cp->af == AF_INET6 ? STYPE_F_INET6 : 0);
 
591
        s->v4.ver_size = htons(len & SVER_MASK);        /* Version 0 */
 
592
        s->v4.flags = htonl(cp->flags & ~IP_VS_CONN_F_HASHED);
 
593
        s->v4.state = htons(cp->state);
 
594
        s->v4.protocol = cp->protocol;
 
595
        s->v4.cport = cp->cport;
 
596
        s->v4.vport = cp->vport;
 
597
        s->v4.dport = cp->dport;
 
598
        s->v4.fwmark = htonl(cp->fwmark);
 
599
        s->v4.timeout = htonl(cp->timeout / HZ);
 
600
        m->nr_conns++;
 
601
 
 
602
#ifdef CONFIG_IP_VS_IPV6
 
603
        if (cp->af == AF_INET6) {
 
604
                p += sizeof(struct ip_vs_sync_v6);
 
605
                ipv6_addr_copy(&s->v6.caddr, &cp->caddr.in6);
 
606
                ipv6_addr_copy(&s->v6.vaddr, &cp->vaddr.in6);
 
607
                ipv6_addr_copy(&s->v6.daddr, &cp->daddr.in6);
 
608
        } else
 
609
#endif
 
610
        {
 
611
                p += sizeof(struct ip_vs_sync_v4);      /* options ptr */
 
612
                s->v4.caddr = cp->caddr.ip;
 
613
                s->v4.vaddr = cp->vaddr.ip;
 
614
                s->v4.daddr = cp->daddr.ip;
 
615
        }
 
616
        if (cp->flags & IP_VS_CONN_F_SEQ_MASK) {
 
617
                *(p++) = IPVS_OPT_SEQ_DATA;
 
618
                *(p++) = sizeof(struct ip_vs_sync_conn_options);
 
619
                hton_seq((struct ip_vs_seq *)p, &cp->in_seq);
 
620
                p += sizeof(struct ip_vs_seq);
 
621
                hton_seq((struct ip_vs_seq *)p, &cp->out_seq);
 
622
                p += sizeof(struct ip_vs_seq);
 
623
        }
 
624
        /* Handle pe data */
 
625
        if (cp->pe_data_len && cp->pe_data) {
 
626
                *(p++) = IPVS_OPT_PE_DATA;
 
627
                *(p++) = cp->pe_data_len;
 
628
                memcpy(p, cp->pe_data, cp->pe_data_len);
 
629
                p += cp->pe_data_len;
 
630
                if (pe_name_len) {
 
631
                        /* Add PE_NAME */
 
632
                        *(p++) = IPVS_OPT_PE_NAME;
 
633
                        *(p++) = pe_name_len;
 
634
                        memcpy(p, cp->pe->name, pe_name_len);
 
635
                        p += pe_name_len;
 
636
                }
 
637
        }
 
638
 
 
639
        spin_unlock(&ipvs->sync_buff_lock);
 
640
 
 
641
control:
 
642
        /* synchronize its controller if it has */
 
643
        cp = cp->control;
 
644
        if (!cp)
 
645
                return;
 
646
        /*
 
647
         * Reduce sync rate for templates
 
648
         * i.e only increment in_pkts for Templates.
 
649
         */
 
650
        if (cp->flags & IP_VS_CONN_F_TEMPLATE) {
 
651
                int pkts = atomic_add_return(1, &cp->in_pkts);
 
652
 
 
653
                if (pkts % sysctl_sync_period(ipvs) != 1)
 
654
                        return;
 
655
        }
 
656
        goto sloop;
 
657
}
 
658
 
 
659
/*
 
660
 *  fill_param used by version 1
 
661
 */
291
662
static inline int
292
 
ip_vs_conn_fill_param_sync(int af, int protocol,
293
 
                           const union nf_inet_addr *caddr, __be16 cport,
294
 
                           const union nf_inet_addr *vaddr, __be16 vport,
295
 
                           struct ip_vs_conn_param *p)
 
663
ip_vs_conn_fill_param_sync(struct net *net, int af, union ip_vs_sync_conn *sc,
 
664
                           struct ip_vs_conn_param *p,
 
665
                           __u8 *pe_data, unsigned int pe_data_len,
 
666
                           __u8 *pe_name, unsigned int pe_name_len)
296
667
{
297
 
        /* XXX: Need to take into account persistence engine */
298
 
        ip_vs_conn_fill_param(af, protocol, caddr, cport, vaddr, vport, p);
 
668
#ifdef CONFIG_IP_VS_IPV6
 
669
        if (af == AF_INET6)
 
670
                ip_vs_conn_fill_param(net, af, sc->v6.protocol,
 
671
                                      (const union nf_inet_addr *)&sc->v6.caddr,
 
672
                                      sc->v6.cport,
 
673
                                      (const union nf_inet_addr *)&sc->v6.vaddr,
 
674
                                      sc->v6.vport, p);
 
675
        else
 
676
#endif
 
677
                ip_vs_conn_fill_param(net, af, sc->v4.protocol,
 
678
                                      (const union nf_inet_addr *)&sc->v4.caddr,
 
679
                                      sc->v4.cport,
 
680
                                      (const union nf_inet_addr *)&sc->v4.vaddr,
 
681
                                      sc->v4.vport, p);
 
682
        /* Handle pe data */
 
683
        if (pe_data_len) {
 
684
                if (pe_name_len) {
 
685
                        char buff[IP_VS_PENAME_MAXLEN+1];
 
686
 
 
687
                        memcpy(buff, pe_name, pe_name_len);
 
688
                        buff[pe_name_len]=0;
 
689
                        p->pe = __ip_vs_pe_getbyname(buff);
 
690
                        if (!p->pe) {
 
691
                                IP_VS_DBG(3, "BACKUP, no %s engine found/loaded\n",
 
692
                                             buff);
 
693
                                return 1;
 
694
                        }
 
695
                } else {
 
696
                        IP_VS_ERR_RL("BACKUP, Invalid PE parameters\n");
 
697
                        return 1;
 
698
                }
 
699
 
 
700
                p->pe_data = kmemdup(pe_data, pe_data_len, GFP_ATOMIC);
 
701
                if (!p->pe_data) {
 
702
                        if (p->pe->module)
 
703
                                module_put(p->pe->module);
 
704
                        return -ENOMEM;
 
705
                }
 
706
                p->pe_data_len = pe_data_len;
 
707
        }
299
708
        return 0;
300
709
}
301
710
 
302
711
/*
303
 
 *      Process received multicast message and create the corresponding
304
 
 *      ip_vs_conn entries.
305
 
 */
306
 
static void ip_vs_process_message(const char *buffer, const size_t buflen)
307
 
{
308
 
        struct ip_vs_sync_mesg *m = (struct ip_vs_sync_mesg *)buffer;
309
 
        struct ip_vs_sync_conn *s;
 
712
 *  Connection Add / Update.
 
713
 *  Common for version 0 and 1 reception of backup sync_conns.
 
714
 *  Param: ...
 
715
 *         timeout is in sec.
 
716
 */
 
717
static void ip_vs_proc_conn(struct net *net, struct ip_vs_conn_param *param,
 
718
                            unsigned int flags, unsigned int state,
 
719
                            unsigned int protocol, unsigned int type,
 
720
                            const union nf_inet_addr *daddr, __be16 dport,
 
721
                            unsigned long timeout, __u32 fwmark,
 
722
                            struct ip_vs_sync_conn_options *opt)
 
723
{
 
724
        struct ip_vs_dest *dest;
 
725
        struct ip_vs_conn *cp;
 
726
        struct netns_ipvs *ipvs = net_ipvs(net);
 
727
 
 
728
        if (!(flags & IP_VS_CONN_F_TEMPLATE))
 
729
                cp = ip_vs_conn_in_get(param);
 
730
        else
 
731
                cp = ip_vs_ct_in_get(param);
 
732
 
 
733
        if (cp && param->pe_data)       /* Free pe_data */
 
734
                kfree(param->pe_data);
 
735
        if (!cp) {
 
736
                /*
 
737
                 * Find the appropriate destination for the connection.
 
738
                 * If it is not found the connection will remain unbound
 
739
                 * but still handled.
 
740
                 */
 
741
                dest = ip_vs_find_dest(net, type, daddr, dport, param->vaddr,
 
742
                                       param->vport, protocol, fwmark);
 
743
 
 
744
                /*  Set the approprite ativity flag */
 
745
                if (protocol == IPPROTO_TCP) {
 
746
                        if (state != IP_VS_TCP_S_ESTABLISHED)
 
747
                                flags |= IP_VS_CONN_F_INACTIVE;
 
748
                        else
 
749
                                flags &= ~IP_VS_CONN_F_INACTIVE;
 
750
                } else if (protocol == IPPROTO_SCTP) {
 
751
                        if (state != IP_VS_SCTP_S_ESTABLISHED)
 
752
                                flags |= IP_VS_CONN_F_INACTIVE;
 
753
                        else
 
754
                                flags &= ~IP_VS_CONN_F_INACTIVE;
 
755
                }
 
756
                cp = ip_vs_conn_new(param, daddr, dport, flags, dest, fwmark);
 
757
                if (dest)
 
758
                        atomic_dec(&dest->refcnt);
 
759
                if (!cp) {
 
760
                        if (param->pe_data)
 
761
                                kfree(param->pe_data);
 
762
                        IP_VS_DBG(2, "BACKUP, add new conn. failed\n");
 
763
                        return;
 
764
                }
 
765
        } else if (!cp->dest) {
 
766
                dest = ip_vs_try_bind_dest(cp);
 
767
                if (dest)
 
768
                        atomic_dec(&dest->refcnt);
 
769
        } else if ((cp->dest) && (cp->protocol == IPPROTO_TCP) &&
 
770
                (cp->state != state)) {
 
771
                /* update active/inactive flag for the connection */
 
772
                dest = cp->dest;
 
773
                if (!(cp->flags & IP_VS_CONN_F_INACTIVE) &&
 
774
                        (state != IP_VS_TCP_S_ESTABLISHED)) {
 
775
                        atomic_dec(&dest->activeconns);
 
776
                        atomic_inc(&dest->inactconns);
 
777
                        cp->flags |= IP_VS_CONN_F_INACTIVE;
 
778
                } else if ((cp->flags & IP_VS_CONN_F_INACTIVE) &&
 
779
                        (state == IP_VS_TCP_S_ESTABLISHED)) {
 
780
                        atomic_inc(&dest->activeconns);
 
781
                        atomic_dec(&dest->inactconns);
 
782
                        cp->flags &= ~IP_VS_CONN_F_INACTIVE;
 
783
                }
 
784
        } else if ((cp->dest) && (cp->protocol == IPPROTO_SCTP) &&
 
785
                (cp->state != state)) {
 
786
                dest = cp->dest;
 
787
                if (!(cp->flags & IP_VS_CONN_F_INACTIVE) &&
 
788
                (state != IP_VS_SCTP_S_ESTABLISHED)) {
 
789
                        atomic_dec(&dest->activeconns);
 
790
                        atomic_inc(&dest->inactconns);
 
791
                        cp->flags &= ~IP_VS_CONN_F_INACTIVE;
 
792
                }
 
793
        }
 
794
 
 
795
        if (opt)
 
796
                memcpy(&cp->in_seq, opt, sizeof(*opt));
 
797
        atomic_set(&cp->in_pkts, sysctl_sync_threshold(ipvs));
 
798
        cp->state = state;
 
799
        cp->old_state = cp->state;
 
800
        /*
 
801
         * For Ver 0 messages style
 
802
         *  - Not possible to recover the right timeout for templates
 
803
         *  - can not find the right fwmark
 
804
         *    virtual service. If needed, we can do it for
 
805
         *    non-fwmark persistent services.
 
806
         * Ver 1 messages style.
 
807
         *  - No problem.
 
808
         */
 
809
        if (timeout) {
 
810
                if (timeout > MAX_SCHEDULE_TIMEOUT / HZ)
 
811
                        timeout = MAX_SCHEDULE_TIMEOUT / HZ;
 
812
                cp->timeout = timeout*HZ;
 
813
        } else {
 
814
                struct ip_vs_proto_data *pd;
 
815
 
 
816
                pd = ip_vs_proto_data_get(net, protocol);
 
817
                if (!(flags & IP_VS_CONN_F_TEMPLATE) && pd && pd->timeout_table)
 
818
                        cp->timeout = pd->timeout_table[state];
 
819
                else
 
820
                        cp->timeout = (3*60*HZ);
 
821
        }
 
822
        ip_vs_conn_put(cp);
 
823
}
 
824
 
 
825
/*
 
826
 *  Process received multicast message for Version 0
 
827
 */
 
828
static void ip_vs_process_message_v0(struct net *net, const char *buffer,
 
829
                                     const size_t buflen)
 
830
{
 
831
        struct ip_vs_sync_mesg_v0 *m = (struct ip_vs_sync_mesg_v0 *)buffer;
 
832
        struct ip_vs_sync_conn_v0 *s;
310
833
        struct ip_vs_sync_conn_options *opt;
311
 
        struct ip_vs_conn *cp;
312
834
        struct ip_vs_protocol *pp;
313
 
        struct ip_vs_dest *dest;
314
835
        struct ip_vs_conn_param param;
315
836
        char *p;
316
837
        int i;
317
838
 
318
 
        if (buflen < sizeof(struct ip_vs_sync_mesg)) {
319
 
                IP_VS_ERR_RL("sync message header too short\n");
320
 
                return;
321
 
        }
322
 
 
323
 
        /* Convert size back to host byte order */
324
 
        m->size = ntohs(m->size);
325
 
 
326
 
        if (buflen != m->size) {
327
 
                IP_VS_ERR_RL("bogus sync message size\n");
328
 
                return;
329
 
        }
330
 
 
331
 
        /* SyncID sanity check */
332
 
        if (ip_vs_backup_syncid != 0 && m->syncid != ip_vs_backup_syncid) {
333
 
                IP_VS_DBG(7, "Ignoring incoming msg with syncid = %d\n",
334
 
                          m->syncid);
335
 
                return;
336
 
        }
337
 
 
338
 
        p = (char *)buffer + sizeof(struct ip_vs_sync_mesg);
 
839
        p = (char *)buffer + sizeof(struct ip_vs_sync_mesg_v0);
339
840
        for (i=0; i<m->nr_conns; i++) {
340
841
                unsigned flags, state;
341
842
 
342
843
                if (p + SIMPLE_CONN_SIZE > buffer+buflen) {
343
 
                        IP_VS_ERR_RL("bogus conn in sync message\n");
 
844
                        IP_VS_ERR_RL("BACKUP v0, bogus conn\n");
344
845
                        return;
345
846
                }
346
 
                s = (struct ip_vs_sync_conn *) p;
 
847
                s = (struct ip_vs_sync_conn_v0 *) p;
347
848
                flags = ntohs(s->flags) | IP_VS_CONN_F_SYNC;
348
849
                flags &= ~IP_VS_CONN_F_HASHED;
349
850
                if (flags & IP_VS_CONN_F_SEQ_MASK) {
350
851
                        opt = (struct ip_vs_sync_conn_options *)&s[1];
351
852
                        p += FULL_CONN_SIZE;
352
853
                        if (p > buffer+buflen) {
353
 
                                IP_VS_ERR_RL("bogus conn options in sync message\n");
 
854
                                IP_VS_ERR_RL("BACKUP v0, Dropping buffer bogus conn options\n");
354
855
                                return;
355
856
                        }
356
857
                } else {
362
863
                if (!(flags & IP_VS_CONN_F_TEMPLATE)) {
363
864
                        pp = ip_vs_proto_get(s->protocol);
364
865
                        if (!pp) {
365
 
                                IP_VS_ERR_RL("Unsupported protocol %u in sync msg\n",
 
866
                                IP_VS_DBG(2, "BACKUP v0, Unsupported protocol %u\n",
366
867
                                        s->protocol);
367
868
                                continue;
368
869
                        }
369
870
                        if (state >= pp->num_states) {
370
 
                                IP_VS_DBG(2, "Invalid %s state %u in sync msg\n",
 
871
                                IP_VS_DBG(2, "BACKUP v0, Invalid %s state %u\n",
371
872
                                        pp->name, state);
372
873
                                continue;
373
874
                        }
374
875
                } else {
375
876
                        /* protocol in templates is not used for state/timeout */
376
 
                        pp = NULL;
377
877
                        if (state > 0) {
378
 
                                IP_VS_DBG(2, "Invalid template state %u in sync msg\n",
 
878
                                IP_VS_DBG(2, "BACKUP v0, Invalid template state %u\n",
379
879
                                        state);
380
880
                                state = 0;
381
881
                        }
382
882
                }
383
883
 
384
 
                {
385
 
                        if (ip_vs_conn_fill_param_sync(AF_INET, s->protocol,
386
 
                                              (union nf_inet_addr *)&s->caddr,
387
 
                                              s->cport,
388
 
                                              (union nf_inet_addr *)&s->vaddr,
389
 
                                              s->vport, &param)) {
390
 
                                pr_err("ip_vs_conn_fill_param_sync failed");
391
 
                                return;
392
 
                        }
393
 
                        if (!(flags & IP_VS_CONN_F_TEMPLATE))
394
 
                                cp = ip_vs_conn_in_get(&param);
395
 
                        else
396
 
                                cp = ip_vs_ct_in_get(&param);
397
 
                }
398
 
                if (!cp) {
399
 
                        /*
400
 
                         * Find the appropriate destination for the connection.
401
 
                         * If it is not found the connection will remain unbound
402
 
                         * but still handled.
403
 
                         */
404
 
                        dest = ip_vs_find_dest(AF_INET,
405
 
                                               (union nf_inet_addr *)&s->daddr,
406
 
                                               s->dport,
407
 
                                               (union nf_inet_addr *)&s->vaddr,
408
 
                                               s->vport,
409
 
                                               s->protocol);
410
 
                        /*  Set the approprite ativity flag */
411
 
                        if (s->protocol == IPPROTO_TCP) {
412
 
                                if (state != IP_VS_TCP_S_ESTABLISHED)
413
 
                                        flags |= IP_VS_CONN_F_INACTIVE;
414
 
                                else
415
 
                                        flags &= ~IP_VS_CONN_F_INACTIVE;
416
 
                        } else if (s->protocol == IPPROTO_SCTP) {
417
 
                                if (state != IP_VS_SCTP_S_ESTABLISHED)
418
 
                                        flags |= IP_VS_CONN_F_INACTIVE;
419
 
                                else
420
 
                                        flags &= ~IP_VS_CONN_F_INACTIVE;
421
 
                        }
422
 
                        cp = ip_vs_conn_new(&param,
423
 
                                            (union nf_inet_addr *)&s->daddr,
424
 
                                            s->dport, flags, dest);
425
 
                        if (dest)
426
 
                                atomic_dec(&dest->refcnt);
427
 
                        if (!cp) {
428
 
                                pr_err("ip_vs_conn_new failed\n");
429
 
                                return;
430
 
                        }
431
 
                } else if (!cp->dest) {
432
 
                        dest = ip_vs_try_bind_dest(cp);
433
 
                        if (dest)
434
 
                                atomic_dec(&dest->refcnt);
435
 
                } else if ((cp->dest) && (cp->protocol == IPPROTO_TCP) &&
436
 
                           (cp->state != state)) {
437
 
                        /* update active/inactive flag for the connection */
438
 
                        dest = cp->dest;
439
 
                        if (!(cp->flags & IP_VS_CONN_F_INACTIVE) &&
440
 
                                (state != IP_VS_TCP_S_ESTABLISHED)) {
441
 
                                atomic_dec(&dest->activeconns);
442
 
                                atomic_inc(&dest->inactconns);
443
 
                                cp->flags |= IP_VS_CONN_F_INACTIVE;
444
 
                        } else if ((cp->flags & IP_VS_CONN_F_INACTIVE) &&
445
 
                                (state == IP_VS_TCP_S_ESTABLISHED)) {
446
 
                                atomic_inc(&dest->activeconns);
447
 
                                atomic_dec(&dest->inactconns);
448
 
                                cp->flags &= ~IP_VS_CONN_F_INACTIVE;
449
 
                        }
450
 
                } else if ((cp->dest) && (cp->protocol == IPPROTO_SCTP) &&
451
 
                           (cp->state != state)) {
452
 
                        dest = cp->dest;
453
 
                        if (!(cp->flags & IP_VS_CONN_F_INACTIVE) &&
454
 
                             (state != IP_VS_SCTP_S_ESTABLISHED)) {
455
 
                            atomic_dec(&dest->activeconns);
456
 
                            atomic_inc(&dest->inactconns);
457
 
                            cp->flags &= ~IP_VS_CONN_F_INACTIVE;
458
 
                        }
459
 
                }
460
 
 
461
 
                if (opt)
462
 
                        memcpy(&cp->in_seq, opt, sizeof(*opt));
463
 
                atomic_set(&cp->in_pkts, sysctl_ip_vs_sync_threshold[0]);
464
 
                cp->state = state;
465
 
                cp->old_state = cp->state;
466
 
                /*
467
 
                 * We can not recover the right timeout for templates
468
 
                 * in all cases, we can not find the right fwmark
469
 
                 * virtual service. If needed, we can do it for
470
 
                 * non-fwmark persistent services.
471
 
                 */
472
 
                if (!(flags & IP_VS_CONN_F_TEMPLATE) && pp->timeout_table)
473
 
                        cp->timeout = pp->timeout_table[state];
474
 
                else
475
 
                        cp->timeout = (3*60*HZ);
476
 
                ip_vs_conn_put(cp);
 
884
                ip_vs_conn_fill_param(net, AF_INET, s->protocol,
 
885
                                      (const union nf_inet_addr *)&s->caddr,
 
886
                                      s->cport,
 
887
                                      (const union nf_inet_addr *)&s->vaddr,
 
888
                                      s->vport, &param);
 
889
 
 
890
                /* Send timeout as Zero */
 
891
                ip_vs_proc_conn(net, &param, flags, state, s->protocol, AF_INET,
 
892
                                (union nf_inet_addr *)&s->daddr, s->dport,
 
893
                                0, 0, opt);
 
894
        }
 
895
}
 
896
 
 
897
/*
 
898
 * Handle options
 
899
 */
 
900
static inline int ip_vs_proc_seqopt(__u8 *p, unsigned int plen,
 
901
                                    __u32 *opt_flags,
 
902
                                    struct ip_vs_sync_conn_options *opt)
 
903
{
 
904
        struct ip_vs_sync_conn_options *topt;
 
905
 
 
906
        topt = (struct ip_vs_sync_conn_options *)p;
 
907
 
 
908
        if (plen != sizeof(struct ip_vs_sync_conn_options)) {
 
909
                IP_VS_DBG(2, "BACKUP, bogus conn options length\n");
 
910
                return -EINVAL;
 
911
        }
 
912
        if (*opt_flags & IPVS_OPT_F_SEQ_DATA) {
 
913
                IP_VS_DBG(2, "BACKUP, conn options found twice\n");
 
914
                return -EINVAL;
 
915
        }
 
916
        ntoh_seq(&topt->in_seq, &opt->in_seq);
 
917
        ntoh_seq(&topt->out_seq, &opt->out_seq);
 
918
        *opt_flags |= IPVS_OPT_F_SEQ_DATA;
 
919
        return 0;
 
920
}
 
921
 
 
922
static int ip_vs_proc_str(__u8 *p, unsigned int plen, unsigned int *data_len,
 
923
                          __u8 **data, unsigned int maxlen,
 
924
                          __u32 *opt_flags, __u32 flag)
 
925
{
 
926
        if (plen > maxlen) {
 
927
                IP_VS_DBG(2, "BACKUP, bogus par.data len > %d\n", maxlen);
 
928
                return -EINVAL;
 
929
        }
 
930
        if (*opt_flags & flag) {
 
931
                IP_VS_DBG(2, "BACKUP, Par.data found twice 0x%x\n", flag);
 
932
                return -EINVAL;
 
933
        }
 
934
        *data_len = plen;
 
935
        *data = p;
 
936
        *opt_flags |= flag;
 
937
        return 0;
 
938
}
 
939
/*
 
940
 *   Process a Version 1 sync. connection
 
941
 */
 
942
static inline int ip_vs_proc_sync_conn(struct net *net, __u8 *p, __u8 *msg_end)
 
943
{
 
944
        struct ip_vs_sync_conn_options opt;
 
945
        union  ip_vs_sync_conn *s;
 
946
        struct ip_vs_protocol *pp;
 
947
        struct ip_vs_conn_param param;
 
948
        __u32 flags;
 
949
        unsigned int af, state, pe_data_len=0, pe_name_len=0;
 
950
        __u8 *pe_data=NULL, *pe_name=NULL;
 
951
        __u32 opt_flags=0;
 
952
        int retc=0;
 
953
 
 
954
        s = (union ip_vs_sync_conn *) p;
 
955
 
 
956
        if (s->v6.type & STYPE_F_INET6) {
 
957
#ifdef CONFIG_IP_VS_IPV6
 
958
                af = AF_INET6;
 
959
                p += sizeof(struct ip_vs_sync_v6);
 
960
#else
 
961
                IP_VS_DBG(3,"BACKUP, IPv6 msg received, and IPVS is not compiled for IPv6\n");
 
962
                retc = 10;
 
963
                goto out;
 
964
#endif
 
965
        } else if (!s->v4.type) {
 
966
                af = AF_INET;
 
967
                p += sizeof(struct ip_vs_sync_v4);
 
968
        } else {
 
969
                return -10;
 
970
        }
 
971
        if (p > msg_end)
 
972
                return -20;
 
973
 
 
974
        /* Process optional params check Type & Len. */
 
975
        while (p < msg_end) {
 
976
                int ptype;
 
977
                int plen;
 
978
 
 
979
                if (p+2 > msg_end)
 
980
                        return -30;
 
981
                ptype = *(p++);
 
982
                plen  = *(p++);
 
983
 
 
984
                if (!plen || ((p + plen) > msg_end))
 
985
                        return -40;
 
986
                /* Handle seq option  p = param data */
 
987
                switch (ptype & ~IPVS_OPT_F_PARAM) {
 
988
                case IPVS_OPT_SEQ_DATA:
 
989
                        if (ip_vs_proc_seqopt(p, plen, &opt_flags, &opt))
 
990
                                return -50;
 
991
                        break;
 
992
 
 
993
                case IPVS_OPT_PE_DATA:
 
994
                        if (ip_vs_proc_str(p, plen, &pe_data_len, &pe_data,
 
995
                                           IP_VS_PEDATA_MAXLEN, &opt_flags,
 
996
                                           IPVS_OPT_F_PE_DATA))
 
997
                                return -60;
 
998
                        break;
 
999
 
 
1000
                case IPVS_OPT_PE_NAME:
 
1001
                        if (ip_vs_proc_str(p, plen,&pe_name_len, &pe_name,
 
1002
                                           IP_VS_PENAME_MAXLEN, &opt_flags,
 
1003
                                           IPVS_OPT_F_PE_NAME))
 
1004
                                return -70;
 
1005
                        break;
 
1006
 
 
1007
                default:
 
1008
                        /* Param data mandatory ? */
 
1009
                        if (!(ptype & IPVS_OPT_F_PARAM)) {
 
1010
                                IP_VS_DBG(3, "BACKUP, Unknown mandatory param %d found\n",
 
1011
                                          ptype & ~IPVS_OPT_F_PARAM);
 
1012
                                retc = 20;
 
1013
                                goto out;
 
1014
                        }
 
1015
                }
 
1016
                p += plen;  /* Next option */
 
1017
        }
 
1018
 
 
1019
        /* Get flags and Mask off unsupported */
 
1020
        flags  = ntohl(s->v4.flags) & IP_VS_CONN_F_BACKUP_MASK;
 
1021
        flags |= IP_VS_CONN_F_SYNC;
 
1022
        state = ntohs(s->v4.state);
 
1023
 
 
1024
        if (!(flags & IP_VS_CONN_F_TEMPLATE)) {
 
1025
                pp = ip_vs_proto_get(s->v4.protocol);
 
1026
                if (!pp) {
 
1027
                        IP_VS_DBG(3,"BACKUP, Unsupported protocol %u\n",
 
1028
                                s->v4.protocol);
 
1029
                        retc = 30;
 
1030
                        goto out;
 
1031
                }
 
1032
                if (state >= pp->num_states) {
 
1033
                        IP_VS_DBG(3, "BACKUP, Invalid %s state %u\n",
 
1034
                                pp->name, state);
 
1035
                        retc = 40;
 
1036
                        goto out;
 
1037
                }
 
1038
        } else {
 
1039
                /* protocol in templates is not used for state/timeout */
 
1040
                if (state > 0) {
 
1041
                        IP_VS_DBG(3, "BACKUP, Invalid template state %u\n",
 
1042
                                state);
 
1043
                        state = 0;
 
1044
                }
 
1045
        }
 
1046
        if (ip_vs_conn_fill_param_sync(net, af, s, &param, pe_data,
 
1047
                                       pe_data_len, pe_name, pe_name_len)) {
 
1048
                retc = 50;
 
1049
                goto out;
 
1050
        }
 
1051
        /* If only IPv4, just silent skip IPv6 */
 
1052
        if (af == AF_INET)
 
1053
                ip_vs_proc_conn(net, &param, flags, state, s->v4.protocol, af,
 
1054
                                (union nf_inet_addr *)&s->v4.daddr, s->v4.dport,
 
1055
                                ntohl(s->v4.timeout), ntohl(s->v4.fwmark),
 
1056
                                (opt_flags & IPVS_OPT_F_SEQ_DATA ? &opt : NULL)
 
1057
                                );
 
1058
#ifdef CONFIG_IP_VS_IPV6
 
1059
        else
 
1060
                ip_vs_proc_conn(net, &param, flags, state, s->v6.protocol, af,
 
1061
                                (union nf_inet_addr *)&s->v6.daddr, s->v6.dport,
 
1062
                                ntohl(s->v6.timeout), ntohl(s->v6.fwmark),
 
1063
                                (opt_flags & IPVS_OPT_F_SEQ_DATA ? &opt : NULL)
 
1064
                                );
 
1065
#endif
 
1066
        return 0;
 
1067
        /* Error exit */
 
1068
out:
 
1069
        IP_VS_DBG(2, "BACKUP, Single msg dropped err:%d\n", retc);
 
1070
        return retc;
 
1071
 
 
1072
}
 
1073
/*
 
1074
 *      Process received multicast message and create the corresponding
 
1075
 *      ip_vs_conn entries.
 
1076
 *      Handles Version 0 & 1
 
1077
 */
 
1078
static void ip_vs_process_message(struct net *net, __u8 *buffer,
 
1079
                                  const size_t buflen)
 
1080
{
 
1081
        struct netns_ipvs *ipvs = net_ipvs(net);
 
1082
        struct ip_vs_sync_mesg *m2 = (struct ip_vs_sync_mesg *)buffer;
 
1083
        __u8 *p, *msg_end;
 
1084
        int i, nr_conns;
 
1085
 
 
1086
        if (buflen < sizeof(struct ip_vs_sync_mesg_v0)) {
 
1087
                IP_VS_DBG(2, "BACKUP, message header too short\n");
 
1088
                return;
 
1089
        }
 
1090
        /* Convert size back to host byte order */
 
1091
        m2->size = ntohs(m2->size);
 
1092
 
 
1093
        if (buflen != m2->size) {
 
1094
                IP_VS_DBG(2, "BACKUP, bogus message size\n");
 
1095
                return;
 
1096
        }
 
1097
        /* SyncID sanity check */
 
1098
        if (ipvs->backup_syncid != 0 && m2->syncid != ipvs->backup_syncid) {
 
1099
                IP_VS_DBG(7, "BACKUP, Ignoring syncid = %d\n", m2->syncid);
 
1100
                return;
 
1101
        }
 
1102
        /* Handle version 1  message */
 
1103
        if ((m2->version == SYNC_PROTO_VER) && (m2->reserved == 0)
 
1104
            && (m2->spare == 0)) {
 
1105
 
 
1106
                msg_end = buffer + sizeof(struct ip_vs_sync_mesg);
 
1107
                nr_conns = m2->nr_conns;
 
1108
 
 
1109
                for (i=0; i<nr_conns; i++) {
 
1110
                        union ip_vs_sync_conn *s;
 
1111
                        unsigned size;
 
1112
                        int retc;
 
1113
 
 
1114
                        p = msg_end;
 
1115
                        if (p + sizeof(s->v4) > buffer+buflen) {
 
1116
                                IP_VS_ERR_RL("BACKUP, Dropping buffer, to small\n");
 
1117
                                return;
 
1118
                        }
 
1119
                        s = (union ip_vs_sync_conn *)p;
 
1120
                        size = ntohs(s->v4.ver_size) & SVER_MASK;
 
1121
                        msg_end = p + size;
 
1122
                        /* Basic sanity checks */
 
1123
                        if (msg_end  > buffer+buflen) {
 
1124
                                IP_VS_ERR_RL("BACKUP, Dropping buffer, msg > buffer\n");
 
1125
                                return;
 
1126
                        }
 
1127
                        if (ntohs(s->v4.ver_size) >> SVER_SHIFT) {
 
1128
                                IP_VS_ERR_RL("BACKUP, Dropping buffer, Unknown version %d\n",
 
1129
                                              ntohs(s->v4.ver_size) >> SVER_SHIFT);
 
1130
                                return;
 
1131
                        }
 
1132
                        /* Process a single sync_conn */
 
1133
                        retc = ip_vs_proc_sync_conn(net, p, msg_end);
 
1134
                        if (retc < 0) {
 
1135
                                IP_VS_ERR_RL("BACKUP, Dropping buffer, Err: %d in decoding\n",
 
1136
                                             retc);
 
1137
                                return;
 
1138
                        }
 
1139
                        /* Make sure we have 32 bit alignment */
 
1140
                        msg_end = p + ((size + 3) & ~3);
 
1141
                }
 
1142
        } else {
 
1143
                /* Old type of message */
 
1144
                ip_vs_process_message_v0(net, buffer, buflen);
 
1145
                return;
477
1146
        }
478
1147
}
479
1148
 
511
1180
{
512
1181
        struct net_device *dev;
513
1182
        struct inet_sock *inet = inet_sk(sk);
 
1183
        struct net *net = sock_net(sk);
514
1184
 
515
 
        if ((dev = __dev_get_by_name(&init_net, ifname)) == NULL)
 
1185
        dev = __dev_get_by_name(net, ifname);
 
1186
        if (!dev)
516
1187
                return -ENODEV;
517
1188
 
518
1189
        if (sk->sk_bound_dev_if && dev->ifindex != sk->sk_bound_dev_if)
531
1202
 *      Set the maximum length of sync message according to the
532
1203
 *      specified interface's MTU.
533
1204
 */
534
 
static int set_sync_mesg_maxlen(int sync_state)
 
1205
static int set_sync_mesg_maxlen(struct net *net, int sync_state)
535
1206
{
 
1207
        struct netns_ipvs *ipvs = net_ipvs(net);
536
1208
        struct net_device *dev;
537
1209
        int num;
538
1210
 
539
1211
        if (sync_state == IP_VS_STATE_MASTER) {
540
 
                if ((dev = __dev_get_by_name(&init_net, ip_vs_master_mcast_ifn)) == NULL)
 
1212
                dev = __dev_get_by_name(net, ipvs->master_mcast_ifn);
 
1213
                if (!dev)
541
1214
                        return -ENODEV;
542
1215
 
543
1216
                num = (dev->mtu - sizeof(struct iphdr) -
544
1217
                       sizeof(struct udphdr) -
545
1218
                       SYNC_MESG_HEADER_LEN - 20) / SIMPLE_CONN_SIZE;
546
 
                sync_send_mesg_maxlen = SYNC_MESG_HEADER_LEN +
 
1219
                ipvs->send_mesg_maxlen = SYNC_MESG_HEADER_LEN +
547
1220
                        SIMPLE_CONN_SIZE * min(num, MAX_CONNS_PER_SYNCBUFF);
548
1221
                IP_VS_DBG(7, "setting the maximum length of sync sending "
549
 
                          "message %d.\n", sync_send_mesg_maxlen);
 
1222
                          "message %d.\n", ipvs->send_mesg_maxlen);
550
1223
        } else if (sync_state == IP_VS_STATE_BACKUP) {
551
 
                if ((dev = __dev_get_by_name(&init_net, ip_vs_backup_mcast_ifn)) == NULL)
 
1224
                dev = __dev_get_by_name(net, ipvs->backup_mcast_ifn);
 
1225
                if (!dev)
552
1226
                        return -ENODEV;
553
1227
 
554
 
                sync_recv_mesg_maxlen = dev->mtu -
 
1228
                ipvs->recv_mesg_maxlen = dev->mtu -
555
1229
                        sizeof(struct iphdr) - sizeof(struct udphdr);
556
1230
                IP_VS_DBG(7, "setting the maximum length of sync receiving "
557
 
                          "message %d.\n", sync_recv_mesg_maxlen);
 
1231
                          "message %d.\n", ipvs->recv_mesg_maxlen);
558
1232
        }
559
1233
 
560
1234
        return 0;
569
1243
static int
570
1244
join_mcast_group(struct sock *sk, struct in_addr *addr, char *ifname)
571
1245
{
 
1246
        struct net *net = sock_net(sk);
572
1247
        struct ip_mreqn mreq;
573
1248
        struct net_device *dev;
574
1249
        int ret;
576
1251
        memset(&mreq, 0, sizeof(mreq));
577
1252
        memcpy(&mreq.imr_multiaddr, addr, sizeof(struct in_addr));
578
1253
 
579
 
        if ((dev = __dev_get_by_name(&init_net, ifname)) == NULL)
 
1254
        dev = __dev_get_by_name(net, ifname);
 
1255
        if (!dev)
580
1256
                return -ENODEV;
581
1257
        if (sk->sk_bound_dev_if && dev->ifindex != sk->sk_bound_dev_if)
582
1258
                return -EINVAL;
593
1269
 
594
1270
static int bind_mcastif_addr(struct socket *sock, char *ifname)
595
1271
{
 
1272
        struct net *net = sock_net(sock->sk);
596
1273
        struct net_device *dev;
597
1274
        __be32 addr;
598
1275
        struct sockaddr_in sin;
599
1276
 
600
 
        if ((dev = __dev_get_by_name(&init_net, ifname)) == NULL)
 
1277
        dev = __dev_get_by_name(net, ifname);
 
1278
        if (!dev)
601
1279
                return -ENODEV;
602
1280
 
603
1281
        addr = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
619
1297
/*
620
1298
 *      Set up sending multicast socket over UDP
621
1299
 */
622
 
static struct socket * make_send_sock(void)
 
1300
static struct socket *make_send_sock(struct net *net)
623
1301
{
 
1302
        struct netns_ipvs *ipvs = net_ipvs(net);
624
1303
        struct socket *sock;
625
1304
        int result;
626
1305
 
627
 
        /* First create a socket */
 
1306
        /* First create a socket move it to right name space later */
628
1307
        result = sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock);
629
1308
        if (result < 0) {
630
1309
                pr_err("Error during creation of socket; terminating\n");
631
1310
                return ERR_PTR(result);
632
1311
        }
633
 
 
634
 
        result = set_mcast_if(sock->sk, ip_vs_master_mcast_ifn);
 
1312
        /*
 
1313
         * Kernel sockets that are a part of a namespace, should not
 
1314
         * hold a reference to a namespace in order to allow to stop it.
 
1315
         * After sk_change_net should be released using sk_release_kernel.
 
1316
         */
 
1317
        sk_change_net(sock->sk, net);
 
1318
        result = set_mcast_if(sock->sk, ipvs->master_mcast_ifn);
635
1319
        if (result < 0) {
636
1320
                pr_err("Error setting outbound mcast interface\n");
637
1321
                goto error;
640
1324
        set_mcast_loop(sock->sk, 0);
641
1325
        set_mcast_ttl(sock->sk, 1);
642
1326
 
643
 
        result = bind_mcastif_addr(sock, ip_vs_master_mcast_ifn);
 
1327
        result = bind_mcastif_addr(sock, ipvs->master_mcast_ifn);
644
1328
        if (result < 0) {
645
1329
                pr_err("Error binding address of the mcast interface\n");
646
1330
                goto error;
655
1339
 
656
1340
        return sock;
657
1341
 
658
 
  error:
659
 
        sock_release(sock);
 
1342
error:
 
1343
        sk_release_kernel(sock->sk);
660
1344
        return ERR_PTR(result);
661
1345
}
662
1346
 
664
1348
/*
665
1349
 *      Set up receiving multicast socket over UDP
666
1350
 */
667
 
static struct socket * make_receive_sock(void)
 
1351
static struct socket *make_receive_sock(struct net *net)
668
1352
{
 
1353
        struct netns_ipvs *ipvs = net_ipvs(net);
669
1354
        struct socket *sock;
670
1355
        int result;
671
1356
 
675
1360
                pr_err("Error during creation of socket; terminating\n");
676
1361
                return ERR_PTR(result);
677
1362
        }
678
 
 
 
1363
        /*
 
1364
         * Kernel sockets that are a part of a namespace, should not
 
1365
         * hold a reference to a namespace in order to allow to stop it.
 
1366
         * After sk_change_net should be released using sk_release_kernel.
 
1367
         */
 
1368
        sk_change_net(sock->sk, net);
679
1369
        /* it is equivalent to the REUSEADDR option in user-space */
680
1370
        sock->sk->sk_reuse = 1;
681
1371
 
689
1379
        /* join the multicast group */
690
1380
        result = join_mcast_group(sock->sk,
691
1381
                        (struct in_addr *) &mcast_addr.sin_addr,
692
 
                        ip_vs_backup_mcast_ifn);
 
1382
                        ipvs->backup_mcast_ifn);
693
1383
        if (result < 0) {
694
1384
                pr_err("Error joining to the multicast group\n");
695
1385
                goto error;
697
1387
 
698
1388
        return sock;
699
1389
 
700
 
  error:
701
 
        sock_release(sock);
 
1390
error:
 
1391
        sk_release_kernel(sock->sk);
702
1392
        return ERR_PTR(result);
703
1393
}
704
1394
 
760
1450
static int sync_thread_master(void *data)
761
1451
{
762
1452
        struct ip_vs_sync_thread_data *tinfo = data;
 
1453
        struct netns_ipvs *ipvs = net_ipvs(tinfo->net);
763
1454
        struct ip_vs_sync_buff *sb;
764
1455
 
765
1456
        pr_info("sync thread started: state = MASTER, mcast_ifn = %s, "
766
1457
                "syncid = %d\n",
767
 
                ip_vs_master_mcast_ifn, ip_vs_master_syncid);
 
1458
                ipvs->master_mcast_ifn, ipvs->master_syncid);
768
1459
 
769
1460
        while (!kthread_should_stop()) {
770
 
                while ((sb = sb_dequeue())) {
 
1461
                while ((sb = sb_dequeue(ipvs))) {
771
1462
                        ip_vs_send_sync_msg(tinfo->sock, sb->mesg);
772
1463
                        ip_vs_sync_buff_release(sb);
773
1464
                }
774
1465
 
775
 
                /* check if entries stay in curr_sb for 2 seconds */
776
 
                sb = get_curr_sync_buff(2 * HZ);
 
1466
                /* check if entries stay in ipvs->sync_buff for 2 seconds */
 
1467
                sb = get_curr_sync_buff(ipvs, 2 * HZ);
777
1468
                if (sb) {
778
1469
                        ip_vs_send_sync_msg(tinfo->sock, sb->mesg);
779
1470
                        ip_vs_sync_buff_release(sb);
783
1474
        }
784
1475
 
785
1476
        /* clean up the sync_buff queue */
786
 
        while ((sb=sb_dequeue())) {
 
1477
        while ((sb = sb_dequeue(ipvs)))
787
1478
                ip_vs_sync_buff_release(sb);
788
 
        }
789
1479
 
790
1480
        /* clean up the current sync_buff */
791
 
        if ((sb = get_curr_sync_buff(0))) {
 
1481
        sb = get_curr_sync_buff(ipvs, 0);
 
1482
        if (sb)
792
1483
                ip_vs_sync_buff_release(sb);
793
 
        }
794
1484
 
795
1485
        /* release the sending multicast socket */
796
 
        sock_release(tinfo->sock);
 
1486
        sk_release_kernel(tinfo->sock->sk);
797
1487
        kfree(tinfo);
798
1488
 
799
1489
        return 0;
803
1493
static int sync_thread_backup(void *data)
804
1494
{
805
1495
        struct ip_vs_sync_thread_data *tinfo = data;
 
1496
        struct netns_ipvs *ipvs = net_ipvs(tinfo->net);
806
1497
        int len;
807
1498
 
808
1499
        pr_info("sync thread started: state = BACKUP, mcast_ifn = %s, "
809
1500
                "syncid = %d\n",
810
 
                ip_vs_backup_mcast_ifn, ip_vs_backup_syncid);
 
1501
                ipvs->backup_mcast_ifn, ipvs->backup_syncid);
811
1502
 
812
1503
        while (!kthread_should_stop()) {
813
1504
                wait_event_interruptible(*sk_sleep(tinfo->sock->sk),
817
1508
                /* do we have data now? */
818
1509
                while (!skb_queue_empty(&(tinfo->sock->sk->sk_receive_queue))) {
819
1510
                        len = ip_vs_receive(tinfo->sock, tinfo->buf,
820
 
                                        sync_recv_mesg_maxlen);
 
1511
                                        ipvs->recv_mesg_maxlen);
821
1512
                        if (len <= 0) {
822
1513
                                pr_err("receiving message error\n");
823
1514
                                break;
826
1517
                        /* disable bottom half, because it accesses the data
827
1518
                           shared by softirq while getting/creating conns */
828
1519
                        local_bh_disable();
829
 
                        ip_vs_process_message(tinfo->buf, len);
 
1520
                        ip_vs_process_message(tinfo->net, tinfo->buf, len);
830
1521
                        local_bh_enable();
831
1522
                }
832
1523
        }
833
1524
 
834
1525
        /* release the sending multicast socket */
835
 
        sock_release(tinfo->sock);
 
1526
        sk_release_kernel(tinfo->sock->sk);
836
1527
        kfree(tinfo->buf);
837
1528
        kfree(tinfo);
838
1529
 
840
1531
}
841
1532
 
842
1533
 
843
 
int start_sync_thread(int state, char *mcast_ifn, __u8 syncid)
 
1534
int start_sync_thread(struct net *net, int state, char *mcast_ifn, __u8 syncid)
844
1535
{
845
1536
        struct ip_vs_sync_thread_data *tinfo;
846
1537
        struct task_struct **realtask, *task;
847
1538
        struct socket *sock;
 
1539
        struct netns_ipvs *ipvs = net_ipvs(net);
848
1540
        char *name, *buf = NULL;
849
1541
        int (*threadfn)(void *data);
850
1542
        int result = -ENOMEM;
851
1543
 
852
1544
        IP_VS_DBG(7, "%s(): pid %d\n", __func__, task_pid_nr(current));
853
1545
        IP_VS_DBG(7, "Each ip_vs_sync_conn entry needs %Zd bytes\n",
854
 
                  sizeof(struct ip_vs_sync_conn));
 
1546
                  sizeof(struct ip_vs_sync_conn_v0));
855
1547
 
856
1548
        if (state == IP_VS_STATE_MASTER) {
857
 
                if (sync_master_thread)
 
1549
                if (ipvs->master_thread)
858
1550
                        return -EEXIST;
859
1551
 
860
 
                strlcpy(ip_vs_master_mcast_ifn, mcast_ifn,
861
 
                        sizeof(ip_vs_master_mcast_ifn));
862
 
                ip_vs_master_syncid = syncid;
863
 
                realtask = &sync_master_thread;
864
 
                name = "ipvs_syncmaster";
 
1552
                strlcpy(ipvs->master_mcast_ifn, mcast_ifn,
 
1553
                        sizeof(ipvs->master_mcast_ifn));
 
1554
                ipvs->master_syncid = syncid;
 
1555
                realtask = &ipvs->master_thread;
 
1556
                name = "ipvs_master:%d";
865
1557
                threadfn = sync_thread_master;
866
 
                sock = make_send_sock();
 
1558
                sock = make_send_sock(net);
867
1559
        } else if (state == IP_VS_STATE_BACKUP) {
868
 
                if (sync_backup_thread)
 
1560
                if (ipvs->backup_thread)
869
1561
                        return -EEXIST;
870
1562
 
871
 
                strlcpy(ip_vs_backup_mcast_ifn, mcast_ifn,
872
 
                        sizeof(ip_vs_backup_mcast_ifn));
873
 
                ip_vs_backup_syncid = syncid;
874
 
                realtask = &sync_backup_thread;
875
 
                name = "ipvs_syncbackup";
 
1563
                strlcpy(ipvs->backup_mcast_ifn, mcast_ifn,
 
1564
                        sizeof(ipvs->backup_mcast_ifn));
 
1565
                ipvs->backup_syncid = syncid;
 
1566
                realtask = &ipvs->backup_thread;
 
1567
                name = "ipvs_backup:%d";
876
1568
                threadfn = sync_thread_backup;
877
 
                sock = make_receive_sock();
 
1569
                sock = make_receive_sock(net);
878
1570
        } else {
879
1571
                return -EINVAL;
880
1572
        }
884
1576
                goto out;
885
1577
        }
886
1578
 
887
 
        set_sync_mesg_maxlen(state);
 
1579
        set_sync_mesg_maxlen(net, state);
888
1580
        if (state == IP_VS_STATE_BACKUP) {
889
 
                buf = kmalloc(sync_recv_mesg_maxlen, GFP_KERNEL);
 
1581
                buf = kmalloc(ipvs->recv_mesg_maxlen, GFP_KERNEL);
890
1582
                if (!buf)
891
1583
                        goto outsocket;
892
1584
        }
895
1587
        if (!tinfo)
896
1588
                goto outbuf;
897
1589
 
 
1590
        tinfo->net = net;
898
1591
        tinfo->sock = sock;
899
1592
        tinfo->buf = buf;
900
1593
 
901
 
        task = kthread_run(threadfn, tinfo, name);
 
1594
        task = kthread_run(threadfn, tinfo, name, ipvs->gen);
902
1595
        if (IS_ERR(task)) {
903
1596
                result = PTR_ERR(task);
904
1597
                goto outtinfo;
906
1599
 
907
1600
        /* mark as active */
908
1601
        *realtask = task;
909
 
        ip_vs_sync_state |= state;
 
1602
        ipvs->sync_state |= state;
910
1603
 
911
1604
        /* increase the module use count */
912
1605
        ip_vs_use_count_inc();
918
1611
outbuf:
919
1612
        kfree(buf);
920
1613
outsocket:
921
 
        sock_release(sock);
 
1614
        sk_release_kernel(sock->sk);
922
1615
out:
923
1616
        return result;
924
1617
}
925
1618
 
926
1619
 
927
 
int stop_sync_thread(int state)
 
1620
int stop_sync_thread(struct net *net, int state)
928
1621
{
 
1622
        struct netns_ipvs *ipvs = net_ipvs(net);
 
1623
        int retc = -EINVAL;
 
1624
 
929
1625
        IP_VS_DBG(7, "%s(): pid %d\n", __func__, task_pid_nr(current));
930
1626
 
931
1627
        if (state == IP_VS_STATE_MASTER) {
932
 
                if (!sync_master_thread)
 
1628
                if (!ipvs->master_thread)
933
1629
                        return -ESRCH;
934
1630
 
935
1631
                pr_info("stopping master sync thread %d ...\n",
936
 
                        task_pid_nr(sync_master_thread));
 
1632
                        task_pid_nr(ipvs->master_thread));
937
1633
 
938
1634
                /*
939
1635
                 * The lock synchronizes with sb_queue_tail(), so that we don't
941
1637
                 * progress of stopping the master sync daemon.
942
1638
                 */
943
1639
 
944
 
                spin_lock_bh(&ip_vs_sync_lock);
945
 
                ip_vs_sync_state &= ~IP_VS_STATE_MASTER;
946
 
                spin_unlock_bh(&ip_vs_sync_lock);
947
 
                kthread_stop(sync_master_thread);
948
 
                sync_master_thread = NULL;
 
1640
                spin_lock_bh(&ipvs->sync_lock);
 
1641
                ipvs->sync_state &= ~IP_VS_STATE_MASTER;
 
1642
                spin_unlock_bh(&ipvs->sync_lock);
 
1643
                retc = kthread_stop(ipvs->master_thread);
 
1644
                ipvs->master_thread = NULL;
949
1645
        } else if (state == IP_VS_STATE_BACKUP) {
950
 
                if (!sync_backup_thread)
 
1646
                if (!ipvs->backup_thread)
951
1647
                        return -ESRCH;
952
1648
 
953
1649
                pr_info("stopping backup sync thread %d ...\n",
954
 
                        task_pid_nr(sync_backup_thread));
 
1650
                        task_pid_nr(ipvs->backup_thread));
955
1651
 
956
 
                ip_vs_sync_state &= ~IP_VS_STATE_BACKUP;
957
 
                kthread_stop(sync_backup_thread);
958
 
                sync_backup_thread = NULL;
959
 
        } else {
960
 
                return -EINVAL;
 
1652
                ipvs->sync_state &= ~IP_VS_STATE_BACKUP;
 
1653
                retc = kthread_stop(ipvs->backup_thread);
 
1654
                ipvs->backup_thread = NULL;
961
1655
        }
962
1656
 
963
1657
        /* decrease the module use count */
964
1658
        ip_vs_use_count_dec();
965
1659
 
966
 
        return 0;
 
1660
        return retc;
 
1661
}
 
1662
 
 
1663
/*
 
1664
 * Initialize data struct for each netns
 
1665
 */
 
1666
int __net_init __ip_vs_sync_init(struct net *net)
 
1667
{
 
1668
        struct netns_ipvs *ipvs = net_ipvs(net);
 
1669
 
 
1670
        INIT_LIST_HEAD(&ipvs->sync_queue);
 
1671
        spin_lock_init(&ipvs->sync_lock);
 
1672
        spin_lock_init(&ipvs->sync_buff_lock);
 
1673
 
 
1674
        ipvs->sync_mcast_addr.sin_family = AF_INET;
 
1675
        ipvs->sync_mcast_addr.sin_port = cpu_to_be16(IP_VS_SYNC_PORT);
 
1676
        ipvs->sync_mcast_addr.sin_addr.s_addr = cpu_to_be32(IP_VS_SYNC_GROUP);
 
1677
        return 0;
 
1678
}
 
1679
 
 
1680
void __ip_vs_sync_cleanup(struct net *net)
 
1681
{
 
1682
        int retc;
 
1683
 
 
1684
        retc = stop_sync_thread(net, IP_VS_STATE_MASTER);
 
1685
        if (retc && retc != -ESRCH)
 
1686
                pr_err("Failed to stop Master Daemon\n");
 
1687
 
 
1688
        retc = stop_sync_thread(net, IP_VS_STATE_BACKUP);
 
1689
        if (retc && retc != -ESRCH)
 
1690
                pr_err("Failed to stop Backup Daemon\n");
 
1691
}
 
1692
 
 
1693
int __init ip_vs_sync_init(void)
 
1694
{
 
1695
        return 0;
 
1696
}
 
1697
 
 
1698
void ip_vs_sync_cleanup(void)
 
1699
{
967
1700
}