~serge-hallyn/ubuntu/quantal/lxc/lxc-user-ns

« back to all changes in this revision

Viewing changes to .pc/0091-introduce-container-hooks.patch/src/lxc/conf.c

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn, Stéphane Graber, Serge Hallyn
  • Date: 2012-06-26 13:04:01 UTC
  • Revision ID: package-import@ubuntu.com-20120626130401-8tclzscid8u2lzxu
Tags: 0.8.0~rc1-4ubuntu17
[ Stéphane Graber ]
* 0090-lxc-ubuntu-use-dpkg-add-architecture: Update lxc-ubuntu
  template to use "dpkg --add-architecture" in containers running
  dpkg >= 1.16.2. (LP: #1017862)

[ Serge Hallyn ]
* 0091-introduce-container-hooks.patch: introduce container hooks at several
  points in the container life-cycle.
* Add copyright statement to lxc-aa-custom-profile
* Add debian/hooks/mountcgroups as an example (installed under
  /usr/share/lxc/hooks)

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/*
 
2
 * lxc: linux Container library
 
3
 *
 
4
 * (C) Copyright IBM Corp. 2007, 2008
 
5
 *
 
6
 * Authors:
 
7
 * Daniel Lezcano <dlezcano at fr.ibm.com>
 
8
 *
 
9
 * This library is free software; you can redistribute it and/or
 
10
 * modify it under the terms of the GNU Lesser General Public
 
11
 * License as published by the Free Software Foundation; either
 
12
 * version 2.1 of the License, or (at your option) any later version.
 
13
 *
 
14
 * This library is distributed in the hope that it will be useful,
 
15
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
16
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
17
 * Lesser General Public License for more details.
 
18
 *
 
19
 * You should have received a copy of the GNU Lesser General Public
 
20
 * License along with this library; if not, write to the Free Software
 
21
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 
22
 */
 
23
#define _GNU_SOURCE
 
24
#include <stdio.h>
 
25
#undef _GNU_SOURCE
 
26
#include <stdlib.h>
 
27
#include <stdarg.h>
 
28
#include <errno.h>
 
29
#include <string.h>
 
30
#include <dirent.h>
 
31
#include <mntent.h>
 
32
#include <unistd.h>
 
33
#include <sys/wait.h>
 
34
#include <pty.h>
 
35
 
 
36
#include <linux/loop.h>
 
37
 
 
38
#include <sys/types.h>
 
39
#include <sys/utsname.h>
 
40
#include <sys/param.h>
 
41
#include <sys/stat.h>
 
42
#include <sys/socket.h>
 
43
#include <sys/mount.h>
 
44
#include <sys/mman.h>
 
45
#include <sys/prctl.h>
 
46
#include <sys/capability.h>
 
47
#include <sys/personality.h>
 
48
 
 
49
#include <arpa/inet.h>
 
50
#include <fcntl.h>
 
51
#include <netinet/in.h>
 
52
#include <net/if.h>
 
53
#include <libgen.h>
 
54
 
 
55
#include "network.h"
 
56
#include "error.h"
 
57
#include "parse.h"
 
58
#include "config.h"
 
59
#include "utils.h"
 
60
#include "conf.h"
 
61
#include "log.h"
 
62
#include "lxc.h"        /* for lxc_cgroup_set() */
 
63
#include "caps.h"       /* for lxc_caps_last_cap() */
 
64
 
 
65
lxc_log_define(lxc_conf, lxc);
 
66
 
 
67
#define MAXHWLEN    18
 
68
#define MAXINDEXLEN 20
 
69
#define MAXMTULEN   16
 
70
#define MAXLINELEN  128
 
71
 
 
72
#ifndef MS_DIRSYNC
 
73
#define MS_DIRSYNC  128
 
74
#endif
 
75
 
 
76
#ifndef MS_REC
 
77
#define MS_REC 16384
 
78
#endif
 
79
 
 
80
#ifndef MNT_DETACH
 
81
#define MNT_DETACH 2
 
82
#endif
 
83
 
 
84
#ifndef MS_RELATIME
 
85
#define MS_RELATIME (1 << 21)
 
86
#endif
 
87
 
 
88
#ifndef MS_STRICTATIME
 
89
#define MS_STRICTATIME (1 << 24)
 
90
#endif
 
91
 
 
92
#ifndef CAP_SETFCAP
 
93
#define CAP_SETFCAP 31
 
94
#endif
 
95
 
 
96
#ifndef CAP_MAC_OVERRIDE
 
97
#define CAP_MAC_OVERRIDE 32
 
98
#endif
 
99
 
 
100
#ifndef CAP_MAC_ADMIN
 
101
#define CAP_MAC_ADMIN 33
 
102
#endif
 
103
 
 
104
#ifndef PR_CAPBSET_DROP
 
105
#define PR_CAPBSET_DROP 24
 
106
#endif
 
107
 
 
108
extern int pivot_root(const char * new_root, const char * put_old);
 
109
 
 
110
typedef int (*instanciate_cb)(struct lxc_handler *, struct lxc_netdev *);
 
111
 
 
112
struct mount_opt {
 
113
        char *name;
 
114
        int clear;
 
115
        int flag;
 
116
};
 
117
 
 
118
struct caps_opt {
 
119
        char *name;
 
120
        int value;
 
121
};
 
122
 
 
123
static int instanciate_veth(struct lxc_handler *, struct lxc_netdev *);
 
124
static int instanciate_macvlan(struct lxc_handler *, struct lxc_netdev *);
 
125
static int instanciate_vlan(struct lxc_handler *, struct lxc_netdev *);
 
126
static int instanciate_phys(struct lxc_handler *, struct lxc_netdev *);
 
127
static int instanciate_empty(struct lxc_handler *, struct lxc_netdev *);
 
128
 
 
129
static  instanciate_cb netdev_conf[LXC_NET_MAXCONFTYPE + 1] = {
 
130
        [LXC_NET_VETH]    = instanciate_veth,
 
131
        [LXC_NET_MACVLAN] = instanciate_macvlan,
 
132
        [LXC_NET_VLAN]    = instanciate_vlan,
 
133
        [LXC_NET_PHYS]    = instanciate_phys,
 
134
        [LXC_NET_EMPTY]   = instanciate_empty,
 
135
};
 
136
 
 
137
static struct mount_opt mount_opt[] = {
 
138
        { "defaults",      0, 0              },
 
139
        { "ro",            0, MS_RDONLY      },
 
140
        { "rw",            1, MS_RDONLY      },
 
141
        { "suid",          1, MS_NOSUID      },
 
142
        { "nosuid",        0, MS_NOSUID      },
 
143
        { "dev",           1, MS_NODEV       },
 
144
        { "nodev",         0, MS_NODEV       },
 
145
        { "exec",          1, MS_NOEXEC      },
 
146
        { "noexec",        0, MS_NOEXEC      },
 
147
        { "sync",          0, MS_SYNCHRONOUS },
 
148
        { "async",         1, MS_SYNCHRONOUS },
 
149
        { "dirsync",       0, MS_DIRSYNC     },
 
150
        { "remount",       0, MS_REMOUNT     },
 
151
        { "mand",          0, MS_MANDLOCK    },
 
152
        { "nomand",        1, MS_MANDLOCK    },
 
153
        { "atime",         1, MS_NOATIME     },
 
154
        { "noatime",       0, MS_NOATIME     },
 
155
        { "diratime",      1, MS_NODIRATIME  },
 
156
        { "nodiratime",    0, MS_NODIRATIME  },
 
157
        { "bind",          0, MS_BIND        },
 
158
        { "rbind",         0, MS_BIND|MS_REC },
 
159
        { "relatime",      0, MS_RELATIME    },
 
160
        { "norelatime",    1, MS_RELATIME    },
 
161
        { "strictatime",   0, MS_STRICTATIME },
 
162
        { "nostrictatime", 1, MS_STRICTATIME },
 
163
        { NULL,            0, 0              },
 
164
};
 
165
 
 
166
static struct caps_opt caps_opt[] = {
 
167
        { "chown",             CAP_CHOWN             },
 
168
        { "dac_override",      CAP_DAC_OVERRIDE      },
 
169
        { "dac_read_search",   CAP_DAC_READ_SEARCH   },
 
170
        { "fowner",            CAP_FOWNER            },
 
171
        { "fsetid",            CAP_FSETID            },
 
172
        { "kill",              CAP_KILL              },
 
173
        { "setgid",            CAP_SETGID            },
 
174
        { "setuid",            CAP_SETUID            },
 
175
        { "setpcap",           CAP_SETPCAP           },
 
176
        { "linux_immutable",   CAP_LINUX_IMMUTABLE   },
 
177
        { "net_bind_service",  CAP_NET_BIND_SERVICE  },
 
178
        { "net_broadcast",     CAP_NET_BROADCAST     },
 
179
        { "net_admin",         CAP_NET_ADMIN         },
 
180
        { "net_raw",           CAP_NET_RAW           },
 
181
        { "ipc_lock",          CAP_IPC_LOCK          },
 
182
        { "ipc_owner",         CAP_IPC_OWNER         },
 
183
        { "sys_module",        CAP_SYS_MODULE        },
 
184
        { "sys_rawio",         CAP_SYS_RAWIO         },
 
185
        { "sys_chroot",        CAP_SYS_CHROOT        },
 
186
        { "sys_ptrace",        CAP_SYS_PTRACE        },
 
187
        { "sys_pacct",         CAP_SYS_PACCT         },
 
188
        { "sys_admin",         CAP_SYS_ADMIN         },
 
189
        { "sys_boot",          CAP_SYS_BOOT          },
 
190
        { "sys_nice",          CAP_SYS_NICE          },
 
191
        { "sys_resource",      CAP_SYS_RESOURCE      },
 
192
        { "sys_time",          CAP_SYS_TIME          },
 
193
        { "sys_tty_config",    CAP_SYS_TTY_CONFIG    },
 
194
        { "mknod",             CAP_MKNOD             },
 
195
        { "lease",             CAP_LEASE             },
 
196
#ifdef CAP_AUDIT_WRITE
 
197
        { "audit_write",       CAP_AUDIT_WRITE       },
 
198
#endif
 
199
#ifdef CAP_AUDIT_CONTROL
 
200
        { "audit_control",     CAP_AUDIT_CONTROL     },
 
201
#endif
 
202
        { "setfcap",           CAP_SETFCAP           },
 
203
        { "mac_override",      CAP_MAC_OVERRIDE      },
 
204
        { "mac_admin",         CAP_MAC_ADMIN         },
 
205
#ifdef CAP_SYSLOG
 
206
        { "syslog",            CAP_SYSLOG            },
 
207
#endif
 
208
#ifdef CAP_WAKE_ALARM
 
209
        { "wake_alarm",        CAP_WAKE_ALARM        },
 
210
#endif
 
211
};
 
212
 
 
213
static int run_script(const char *name, const char *section,
 
214
                      const char *script, ...)
 
215
{
 
216
        int ret;
 
217
        FILE *f;
 
218
        char *buffer, *p, *output;
 
219
        size_t size = 0;
 
220
        va_list ap;
 
221
 
 
222
        INFO("Executing script '%s' for container '%s', config section '%s'",
 
223
             script, name, section);
 
224
 
 
225
        va_start(ap, script);
 
226
        while ((p = va_arg(ap, char *)))
 
227
                size += strlen(p) + 1;
 
228
        va_end(ap);
 
229
 
 
230
        size += strlen(script);
 
231
        size += strlen(name);
 
232
        size += strlen(section);
 
233
        size += 3;
 
234
 
 
235
        if (size > INT_MAX)
 
236
                return -1;
 
237
 
 
238
        buffer = alloca(size);
 
239
        if (!buffer) {
 
240
                ERROR("failed to allocate memory");
 
241
                return -1;
 
242
        }
 
243
 
 
244
        ret = snprintf(buffer, size, "%s %s %s", script, name, section);
 
245
        if (ret < 0 || ret >= size) {
 
246
                ERROR("Script name too long");
 
247
                free(buffer);
 
248
                return -1;
 
249
        }
 
250
 
 
251
        va_start(ap, script);
 
252
        while ((p = va_arg(ap, char *))) {
 
253
                int len = size-ret;
 
254
                int rc;
 
255
                rc = snprintf(buffer + ret, len, " %s", p);
 
256
                if (rc < 0 || rc >= len) {
 
257
                        free(buffer);
 
258
                        ERROR("Script args too long");
 
259
                        return -1;
 
260
                }
 
261
                ret += rc;
 
262
        }
 
263
        va_end(ap);
 
264
 
 
265
        f = popen(buffer, "r");
 
266
        if (!f) {
 
267
                SYSERROR("popen failed");
 
268
                return -1;
 
269
        }
 
270
 
 
271
        output = malloc(LXC_LOG_BUFFER_SIZE);
 
272
        if (!output) {
 
273
                ERROR("failed to allocate memory for script output");
 
274
                return -1;
 
275
        }
 
276
 
 
277
        while(fgets(output, LXC_LOG_BUFFER_SIZE, f))
 
278
                DEBUG("script output: %s", output);
 
279
 
 
280
        free(output);
 
281
 
 
282
        if (pclose(f)) {
 
283
                ERROR("Script exited on error");
 
284
                return -1;
 
285
        }
 
286
 
 
287
        return 0;
 
288
}
 
289
 
 
290
static int find_fstype_cb(char* buffer, void *data)
 
291
{
 
292
        struct cbarg {
 
293
                const char *rootfs;
 
294
                const char *target;
 
295
                int mntopt;
 
296
        } *cbarg = data;
 
297
 
 
298
        char *fstype;
 
299
 
 
300
        /* we don't try 'nodev' entries */
 
301
        if (strstr(buffer, "nodev"))
 
302
                return 0;
 
303
 
 
304
        fstype = buffer;
 
305
        fstype += lxc_char_left_gc(fstype, strlen(fstype));
 
306
        fstype[lxc_char_right_gc(fstype, strlen(fstype))] = '\0';
 
307
 
 
308
        DEBUG("trying to mount '%s'->'%s' with fstype '%s'",
 
309
              cbarg->rootfs, cbarg->target, fstype);
 
310
 
 
311
        if (mount(cbarg->rootfs, cbarg->target, fstype, cbarg->mntopt, NULL)) {
 
312
                DEBUG("mount failed with error: %s", strerror(errno));
 
313
                return 0;
 
314
        }
 
315
 
 
316
        INFO("mounted '%s' on '%s', with fstype '%s'",
 
317
             cbarg->rootfs, cbarg->target, fstype);
 
318
 
 
319
        return 1;
 
320
}
 
321
 
 
322
static int mount_unknow_fs(const char *rootfs, const char *target, int mntopt)
 
323
{
 
324
        int i;
 
325
 
 
326
        struct cbarg {
 
327
                const char *rootfs;
 
328
                const char *target;
 
329
                int mntopt;
 
330
        } cbarg = {
 
331
                .rootfs = rootfs,
 
332
                .target = target,
 
333
                .mntopt = mntopt,
 
334
        };
 
335
 
 
336
        /*
 
337
         * find the filesystem type with brute force:
 
338
         * first we check with /etc/filesystems, in case the modules
 
339
         * are auto-loaded and fall back to the supported kernel fs
 
340
         */
 
341
        char *fsfile[] = {
 
342
                "/etc/filesystems",
 
343
                "/proc/filesystems",
 
344
        };
 
345
 
 
346
        for (i = 0; i < sizeof(fsfile)/sizeof(fsfile[0]); i++) {
 
347
 
 
348
                int ret;
 
349
 
 
350
                if (access(fsfile[i], F_OK))
 
351
                        continue;
 
352
 
 
353
                ret = lxc_file_for_each_line(fsfile[i], find_fstype_cb, &cbarg);
 
354
                if (ret < 0) {
 
355
                        ERROR("failed to parse '%s'", fsfile[i]);
 
356
                        return -1;
 
357
                }
 
358
 
 
359
                if (ret)
 
360
                        return 0;
 
361
        }
 
362
 
 
363
        ERROR("failed to determine fs type for '%s'", rootfs);
 
364
        return -1;
 
365
}
 
366
 
 
367
static int mount_rootfs_dir(const char *rootfs, const char *target)
 
368
{
 
369
        return mount(rootfs, target, "none", MS_BIND | MS_REC, NULL);
 
370
}
 
371
 
 
372
static int setup_lodev(const char *rootfs, int fd, struct loop_info64 *loinfo)
 
373
{
 
374
        int rfd;
 
375
        int ret = -1;
 
376
 
 
377
        rfd = open(rootfs, O_RDWR);
 
378
        if (rfd < 0) {
 
379
                SYSERROR("failed to open '%s'", rootfs);
 
380
                return -1;
 
381
        }
 
382
 
 
383
        memset(loinfo, 0, sizeof(*loinfo));
 
384
 
 
385
        loinfo->lo_flags = LO_FLAGS_AUTOCLEAR;
 
386
 
 
387
        if (ioctl(fd, LOOP_SET_FD, rfd)) {
 
388
                SYSERROR("failed to LOOP_SET_FD");
 
389
                goto out;
 
390
        }
 
391
 
 
392
        if (ioctl(fd, LOOP_SET_STATUS64, loinfo)) {
 
393
                SYSERROR("failed to LOOP_SET_STATUS64");
 
394
                goto out;
 
395
        }
 
396
 
 
397
        ret = 0;
 
398
out:
 
399
        close(rfd);
 
400
 
 
401
        return ret;
 
402
}
 
403
 
 
404
static int mount_rootfs_file(const char *rootfs, const char *target)
 
405
{
 
406
        struct dirent dirent, *direntp;
 
407
        struct loop_info64 loinfo;
 
408
        int ret = -1, fd = -1, rc;
 
409
        DIR *dir;
 
410
        char path[MAXPATHLEN];
 
411
 
 
412
        dir = opendir("/dev");
 
413
        if (!dir) {
 
414
                SYSERROR("failed to open '/dev'");
 
415
                return -1;
 
416
        }
 
417
 
 
418
        while (!readdir_r(dir, &dirent, &direntp)) {
 
419
 
 
420
                if (!direntp)
 
421
                        break;
 
422
 
 
423
                if (!strcmp(direntp->d_name, "."))
 
424
                        continue;
 
425
 
 
426
                if (!strcmp(direntp->d_name, ".."))
 
427
                        continue;
 
428
 
 
429
                if (strncmp(direntp->d_name, "loop", 4))
 
430
                        continue;
 
431
 
 
432
                rc = snprintf(path, MAXPATHLEN, "/dev/%s", direntp->d_name);
 
433
                if (rc < 0 || rc >= MAXPATHLEN)
 
434
                        continue;
 
435
 
 
436
                fd = open(path, O_RDWR);
 
437
                if (fd < 0)
 
438
                        continue;
 
439
 
 
440
                if (ioctl(fd, LOOP_GET_STATUS64, &loinfo) == 0) {
 
441
                        close(fd);
 
442
                        continue;
 
443
                }
 
444
 
 
445
                if (errno != ENXIO) {
 
446
                        WARN("unexpected error for ioctl on '%s': %m",
 
447
                             direntp->d_name);
 
448
                        continue;
 
449
                }
 
450
 
 
451
                DEBUG("found '%s' free lodev", path);
 
452
 
 
453
                ret = setup_lodev(rootfs, fd, &loinfo);
 
454
                if (!ret)
 
455
                        ret = mount_unknow_fs(path, target, 0);
 
456
                close(fd);
 
457
 
 
458
                break;
 
459
        }
 
460
 
 
461
        if (closedir(dir))
 
462
                WARN("failed to close directory");
 
463
 
 
464
        return ret;
 
465
}
 
466
 
 
467
static int mount_rootfs_block(const char *rootfs, const char *target)
 
468
{
 
469
        return mount_unknow_fs(rootfs, target, 0);
 
470
}
 
471
 
 
472
/*
 
473
 * pin_rootfs
 
474
 * if rootfs is a directory, then open ${rootfs}.hold for writing for the
 
475
 * duration of the container run, to prevent the container from marking the
 
476
 * underlying fs readonly on shutdown.
 
477
 * return -1 on error.
 
478
 * return -2 if nothing needed to be pinned.
 
479
 * return an open fd (>=0) if we pinned it.
 
480
 */
 
481
int pin_rootfs(const char *rootfs)
 
482
{
 
483
        char absrootfs[MAXPATHLEN];
 
484
        char absrootfspin[MAXPATHLEN];
 
485
        struct stat s;
 
486
        int ret, fd;
 
487
 
 
488
        if (rootfs == NULL || strlen(rootfs) == 0)
 
489
                return 0;
 
490
 
 
491
        if (!realpath(rootfs, absrootfs)) {
 
492
                SYSERROR("failed to get real path for '%s'", rootfs);
 
493
                return -1;
 
494
        }
 
495
 
 
496
        if (access(absrootfs, F_OK)) {
 
497
                SYSERROR("'%s' is not accessible", absrootfs);
 
498
                return -1;
 
499
        }
 
500
 
 
501
        if (stat(absrootfs, &s)) {
 
502
                SYSERROR("failed to stat '%s'", absrootfs);
 
503
                return -1;
 
504
        }
 
505
 
 
506
        if (!__S_ISTYPE(s.st_mode, S_IFDIR))
 
507
                return -2;
 
508
 
 
509
        ret = snprintf(absrootfspin, MAXPATHLEN, "%s%s", absrootfs, ".hold");
 
510
        if (ret >= MAXPATHLEN) {
 
511
                SYSERROR("pathname too long for rootfs hold file");
 
512
                return -1;
 
513
        }
 
514
 
 
515
        fd = open(absrootfspin, O_CREAT | O_RDWR, S_IWUSR|S_IRUSR);
 
516
        INFO("opened %s as fd %d\n", absrootfspin, fd);
 
517
        return fd;
 
518
}
 
519
 
 
520
static int mount_rootfs(const char *rootfs, const char *target)
 
521
{
 
522
        char absrootfs[MAXPATHLEN];
 
523
        struct stat s;
 
524
        int i;
 
525
 
 
526
        typedef int (*rootfs_cb)(const char *, const char *);
 
527
 
 
528
        struct rootfs_type {
 
529
                int type;
 
530
                rootfs_cb cb;
 
531
        } rtfs_type[] = {
 
532
                { S_IFDIR, mount_rootfs_dir },
 
533
                { S_IFBLK, mount_rootfs_block },
 
534
                { S_IFREG, mount_rootfs_file },
 
535
        };
 
536
 
 
537
        if (!realpath(rootfs, absrootfs)) {
 
538
                SYSERROR("failed to get real path for '%s'", rootfs);
 
539
                return -1;
 
540
        }
 
541
 
 
542
        if (access(absrootfs, F_OK)) {
 
543
                SYSERROR("'%s' is not accessible", absrootfs);
 
544
                return -1;
 
545
        }
 
546
 
 
547
        if (stat(absrootfs, &s)) {
 
548
                SYSERROR("failed to stat '%s'", absrootfs);
 
549
                return -1;
 
550
        }
 
551
 
 
552
        for (i = 0; i < sizeof(rtfs_type)/sizeof(rtfs_type[0]); i++) {
 
553
 
 
554
                if (!__S_ISTYPE(s.st_mode, rtfs_type[i].type))
 
555
                        continue;
 
556
 
 
557
                return rtfs_type[i].cb(absrootfs, target);
 
558
        }
 
559
 
 
560
        ERROR("unsupported rootfs type for '%s'", absrootfs);
 
561
        return -1;
 
562
}
 
563
 
 
564
static int setup_utsname(struct utsname *utsname)
 
565
{
 
566
        if (!utsname)
 
567
                return 0;
 
568
 
 
569
        if (sethostname(utsname->nodename, strlen(utsname->nodename))) {
 
570
                SYSERROR("failed to set the hostname to '%s'", utsname->nodename);
 
571
                return -1;
 
572
        }
 
573
 
 
574
        INFO("'%s' hostname has been setup", utsname->nodename);
 
575
 
 
576
        return 0;
 
577
}
 
578
 
 
579
static int setup_tty(const struct lxc_rootfs *rootfs,
 
580
                     const struct lxc_tty_info *tty_info, char *ttydir)
 
581
{
 
582
        char path[MAXPATHLEN], lxcpath[MAXPATHLEN];
 
583
        int i, ret;
 
584
 
 
585
        if (!rootfs->path)
 
586
                return 0;
 
587
 
 
588
        for (i = 0; i < tty_info->nbtty; i++) {
 
589
 
 
590
                struct lxc_pty_info *pty_info = &tty_info->pty_info[i];
 
591
 
 
592
                ret = snprintf(path, sizeof(path), "%s/dev/tty%d",
 
593
                         rootfs->mount, i + 1);
 
594
                if (ret >= sizeof(path)) {
 
595
                        ERROR("pathname too long for ttys");
 
596
                        return -1;
 
597
                }
 
598
                if (ttydir) {
 
599
                        /* create dev/lxc/tty%d" */
 
600
                        ret = snprintf(lxcpath, sizeof(lxcpath), "%s/dev/%s/tty%d",
 
601
                                 rootfs->mount, ttydir, i + 1);
 
602
                        if (ret >= sizeof(lxcpath)) {
 
603
                                ERROR("pathname too long for ttys");
 
604
                                return -1;
 
605
                        }
 
606
                        ret = creat(lxcpath, 0660);
 
607
                        if (ret==-1 && errno != EEXIST) {
 
608
                                SYSERROR("error creating %s\n", lxcpath);
 
609
                                return -1;
 
610
                        }
 
611
                        close(ret);
 
612
                        ret = unlink(path);
 
613
                        if (ret && errno != ENOENT) {
 
614
                                SYSERROR("error unlinking %s\n", path);
 
615
                                return -1;
 
616
                        }
 
617
 
 
618
                        if (mount(pty_info->name, lxcpath, "none", MS_BIND, 0)) {
 
619
                                WARN("failed to mount '%s'->'%s'",
 
620
                                     pty_info->name, path);
 
621
                                continue;
 
622
                        }
 
623
 
 
624
                        ret = snprintf(lxcpath, sizeof(lxcpath), "%s/tty%d", ttydir, i+1);
 
625
                        if (ret >= sizeof(lxcpath)) {
 
626
                                ERROR("tty pathname too long");
 
627
                                return -1;
 
628
                        }
 
629
                        ret = symlink(lxcpath, path);
 
630
                        if (ret) {
 
631
                                SYSERROR("failed to create symlink for tty %d\n", i+1);
 
632
                                return -1;
 
633
                        }
 
634
                } else {
 
635
                        if (mount(pty_info->name, path, "none", MS_BIND, 0)) {
 
636
                                WARN("failed to mount '%s'->'%s'",
 
637
                                                pty_info->name, path);
 
638
                                continue;
 
639
                        }
 
640
                }
 
641
        }
 
642
 
 
643
        INFO("%d tty(s) has been setup", tty_info->nbtty);
 
644
 
 
645
        return 0;
 
646
}
 
647
 
 
648
static int setup_rootfs_pivot_root_cb(char *buffer, void *data)
 
649
{
 
650
        struct lxc_list *mountlist, *listentry, *iterator;
 
651
        char *pivotdir, *mountpoint, *mountentry;
 
652
        int found;
 
653
        void **cbparm;
 
654
 
 
655
        mountentry = buffer;
 
656
        cbparm = (void **)data;
 
657
 
 
658
        mountlist = cbparm[0];
 
659
        pivotdir  = cbparm[1];
 
660
 
 
661
        /* parse entry, first field is mountname, ignore */
 
662
        mountpoint = strtok(mountentry, " ");
 
663
        if (!mountpoint)
 
664
                return -1;
 
665
 
 
666
        /* second field is mountpoint */
 
667
        mountpoint = strtok(NULL, " ");
 
668
        if (!mountpoint)
 
669
                return -1;
 
670
 
 
671
        /* only consider mountpoints below old root fs */
 
672
        if (strncmp(mountpoint, pivotdir, strlen(pivotdir)))
 
673
                return 0;
 
674
 
 
675
        /* filter duplicate mountpoints */
 
676
        found = 0;
 
677
        lxc_list_for_each(iterator, mountlist) {
 
678
                if (!strcmp(iterator->elem, mountpoint)) {
 
679
                        found = 1;
 
680
                        break;
 
681
                }
 
682
        }
 
683
        if (found)
 
684
                return 0;
 
685
 
 
686
        /* add entry to list */
 
687
        listentry = malloc(sizeof(*listentry));
 
688
        if (!listentry) {
 
689
                SYSERROR("malloc for mountpoint listentry failed");
 
690
                return -1;
 
691
        }
 
692
 
 
693
        listentry->elem = strdup(mountpoint);
 
694
        if (!listentry->elem) {
 
695
                SYSERROR("strdup failed");
 
696
                return -1;
 
697
        }
 
698
        lxc_list_add_tail(mountlist, listentry);
 
699
 
 
700
        return 0;
 
701
}
 
702
 
 
703
static int umount_oldrootfs(const char *oldrootfs)
 
704
{
 
705
        char path[MAXPATHLEN];
 
706
        void *cbparm[2];
 
707
        struct lxc_list mountlist, *iterator;
 
708
        int ok, still_mounted, last_still_mounted;
 
709
        int rc;
 
710
 
 
711
        /* read and parse /proc/mounts in old root fs */
 
712
        lxc_list_init(&mountlist);
 
713
 
 
714
        /* oldrootfs is on the top tree directory now */
 
715
        rc = snprintf(path, sizeof(path), "/%s", oldrootfs);
 
716
        if (rc >= sizeof(path)) {
 
717
                ERROR("rootfs name too long");
 
718
                return -1;
 
719
        }
 
720
        cbparm[0] = &mountlist;
 
721
 
 
722
        cbparm[1] = strdup(path);
 
723
        if (!cbparm[1]) {
 
724
                SYSERROR("strdup failed");
 
725
                return -1;
 
726
        }
 
727
 
 
728
        rc = snprintf(path, sizeof(path), "%s/proc/mounts", oldrootfs);
 
729
        if (rc >= sizeof(path)) {
 
730
                ERROR("container proc/mounts name too long");
 
731
                return -1;
 
732
        }
 
733
 
 
734
        ok = lxc_file_for_each_line(path,
 
735
                                    setup_rootfs_pivot_root_cb, &cbparm);
 
736
        if (ok < 0) {
 
737
                SYSERROR("failed to read or parse mount list '%s'", path);
 
738
                return -1;
 
739
        }
 
740
 
 
741
        /* umount filesystems until none left or list no longer shrinks */
 
742
        still_mounted = 0;
 
743
        do {
 
744
                last_still_mounted = still_mounted;
 
745
                still_mounted = 0;
 
746
 
 
747
                lxc_list_for_each(iterator, &mountlist) {
 
748
 
 
749
                        /* umount normally */
 
750
                        if (!umount(iterator->elem)) {
 
751
                                DEBUG("umounted '%s'", (char *)iterator->elem);
 
752
                                lxc_list_del(iterator);
 
753
                                continue;
 
754
                        }
 
755
 
 
756
                        still_mounted++;
 
757
                }
 
758
 
 
759
        } while (still_mounted > 0 && still_mounted != last_still_mounted);
 
760
 
 
761
 
 
762
        lxc_list_for_each(iterator, &mountlist) {
 
763
 
 
764
                /* let's try a lazy umount */
 
765
                if (!umount2(iterator->elem, MNT_DETACH)) {
 
766
                        INFO("lazy unmount of '%s'", (char *)iterator->elem);
 
767
                        continue;
 
768
                }
 
769
 
 
770
                /* be more brutal (nfs) */
 
771
                if (!umount2(iterator->elem, MNT_FORCE)) {
 
772
                        INFO("forced unmount of '%s'", (char *)iterator->elem);
 
773
                        continue;
 
774
                }
 
775
 
 
776
                WARN("failed to unmount '%s'", (char *)iterator->elem);
 
777
        }
 
778
 
 
779
        return 0;
 
780
}
 
781
 
 
782
static int setup_rootfs_pivot_root(const char *rootfs, const char *pivotdir)
 
783
{
 
784
        char path[MAXPATHLEN];
 
785
        int remove_pivotdir = 0;
 
786
        int rc;
 
787
 
 
788
        /* change into new root fs */
 
789
        if (chdir(rootfs)) {
 
790
                SYSERROR("can't chdir to new rootfs '%s'", rootfs);
 
791
                return -1;
 
792
        }
 
793
 
 
794
        if (!pivotdir)
 
795
                pivotdir = "mnt";
 
796
 
 
797
        /* compute the full path to pivotdir under rootfs */
 
798
        rc = snprintf(path, sizeof(path), "%s/%s", rootfs, pivotdir);
 
799
        if (rc >= sizeof(path)) {
 
800
                ERROR("pivot dir name too long");
 
801
                return -1;
 
802
        }
 
803
 
 
804
        if (access(path, F_OK)) {
 
805
 
 
806
                if (mkdir_p(path, 0755)) {
 
807
                        SYSERROR("failed to create pivotdir '%s'", path);
 
808
                        return -1;
 
809
                }
 
810
 
 
811
                remove_pivotdir = 1;
 
812
                DEBUG("created '%s' directory", path);
 
813
        }
 
814
 
 
815
        DEBUG("mountpoint for old rootfs is '%s'", path);
 
816
 
 
817
        /* pivot_root into our new root fs */
 
818
        if (pivot_root(".", path)) {
 
819
                SYSERROR("pivot_root syscall failed");
 
820
                return -1;
 
821
        }
 
822
 
 
823
        if (chdir("/")) {
 
824
                SYSERROR("can't chdir to / after pivot_root");
 
825
                return -1;
 
826
        }
 
827
 
 
828
        DEBUG("pivot_root syscall to '%s' successful", rootfs);
 
829
 
 
830
        /* we switch from absolute path to relative path */
 
831
        if (umount_oldrootfs(pivotdir))
 
832
                return -1;
 
833
 
 
834
        /* remove temporary mount point, we don't consider the removing
 
835
         * as fatal */
 
836
        if (remove_pivotdir && rmdir(pivotdir))
 
837
                WARN("can't remove mountpoint '%s': %m", pivotdir);
 
838
 
 
839
        return 0;
 
840
}
 
841
 
 
842
static int setup_rootfs(const struct lxc_rootfs *rootfs)
 
843
{
 
844
        if (!rootfs->path)
 
845
                return 0;
 
846
 
 
847
        if (access(rootfs->mount, F_OK)) {
 
848
                SYSERROR("failed to access to '%s', check it is present",
 
849
                         rootfs->mount);
 
850
                return -1;
 
851
        }
 
852
 
 
853
        if (mount_rootfs(rootfs->path, rootfs->mount)) {
 
854
                ERROR("failed to mount rootfs");
 
855
                return -1;
 
856
        }
 
857
 
 
858
        DEBUG("mounted '%s' on '%s'", rootfs->path, rootfs->mount);
 
859
 
 
860
        return 0;
 
861
}
 
862
 
 
863
int setup_pivot_root(const struct lxc_rootfs *rootfs)
 
864
{
 
865
        if (!rootfs->path)
 
866
                return 0;
 
867
 
 
868
        if (setup_rootfs_pivot_root(rootfs->mount, rootfs->pivot)) {
 
869
                ERROR("failed to setup pivot root");
 
870
                return -1;
 
871
        }
 
872
 
 
873
        return 0;
 
874
}
 
875
 
 
876
static int setup_pts(int pts)
 
877
{
 
878
        char target[PATH_MAX];
 
879
 
 
880
        if (!pts)
 
881
                return 0;
 
882
 
 
883
        if (!access("/dev/pts/ptmx", F_OK) && umount("/dev/pts")) {
 
884
                SYSERROR("failed to umount 'dev/pts'");
 
885
                return -1;
 
886
        }
 
887
 
 
888
        if (mount("devpts", "/dev/pts", "devpts", MS_MGC_VAL,
 
889
                  "newinstance,ptmxmode=0666")) {
 
890
                SYSERROR("failed to mount a new instance of '/dev/pts'");
 
891
                return -1;
 
892
        }
 
893
 
 
894
        if (access("/dev/ptmx", F_OK)) {
 
895
                if (!symlink("/dev/pts/ptmx", "/dev/ptmx"))
 
896
                        goto out;
 
897
                SYSERROR("failed to symlink '/dev/pts/ptmx'->'/dev/ptmx'");
 
898
                return -1;
 
899
        }
 
900
 
 
901
        if (realpath("/dev/ptmx", target) && !strcmp(target, "/dev/pts/ptmx"))
 
902
                goto out;
 
903
 
 
904
        /* fallback here, /dev/pts/ptmx exists just mount bind */
 
905
        if (mount("/dev/pts/ptmx", "/dev/ptmx", "none", MS_BIND, 0)) {
 
906
                SYSERROR("mount failed '/dev/pts/ptmx'->'/dev/ptmx'");
 
907
                return -1;
 
908
        }
 
909
 
 
910
        INFO("created new pts instance");
 
911
 
 
912
out:
 
913
        return 0;
 
914
}
 
915
 
 
916
static int setup_personality(int persona)
 
917
{
 
918
        if (persona == -1)
 
919
                return 0;
 
920
 
 
921
        if (personality(persona) < 0) {
 
922
                SYSERROR("failed to set personality to '0x%x'", persona);
 
923
                return -1;
 
924
        }
 
925
 
 
926
        INFO("set personality to '0x%x'", persona);
 
927
 
 
928
        return 0;
 
929
}
 
930
 
 
931
static int setup_dev_console(const struct lxc_rootfs *rootfs,
 
932
                         const struct lxc_console *console)
 
933
{
 
934
        char path[MAXPATHLEN];
 
935
        struct stat s;
 
936
        int ret;
 
937
 
 
938
        ret = snprintf(path, sizeof(path), "%s/dev/console", rootfs->mount);
 
939
        if (ret >= sizeof(path)) {
 
940
                ERROR("console path too long\n");
 
941
                return -1;
 
942
        }
 
943
 
 
944
        if (access(path, F_OK)) {
 
945
                WARN("rootfs specified but no console found at '%s'", path);
 
946
                return 0;
 
947
        }
 
948
 
 
949
        if (console->peer == -1) {
 
950
                INFO("no console output required");
 
951
                return 0;
 
952
        }
 
953
 
 
954
        if (stat(path, &s)) {
 
955
                SYSERROR("failed to stat '%s'", path);
 
956
                return -1;
 
957
        }
 
958
 
 
959
        if (chmod(console->name, s.st_mode)) {
 
960
                SYSERROR("failed to set mode '0%o' to '%s'",
 
961
                         s.st_mode, console->name);
 
962
                return -1;
 
963
        }
 
964
 
 
965
        if (mount(console->name, path, "none", MS_BIND, 0)) {
 
966
                ERROR("failed to mount '%s' on '%s'", console->name, path);
 
967
                return -1;
 
968
        }
 
969
 
 
970
        INFO("console has been setup");
 
971
        return 0;
 
972
}
 
973
 
 
974
static int setup_ttydir_console(const struct lxc_rootfs *rootfs,
 
975
                         const struct lxc_console *console,
 
976
                         char *ttydir)
 
977
{
 
978
        char path[MAXPATHLEN], lxcpath[MAXPATHLEN];
 
979
        int ret;
 
980
 
 
981
        /* create rootfs/dev/<ttydir> directory */
 
982
        ret = snprintf(path, sizeof(path), "%s/dev/%s", rootfs->mount,
 
983
                       ttydir);
 
984
        if (ret >= sizeof(path))
 
985
                return -1;
 
986
        ret = mkdir(path, 0755);
 
987
        if (ret && errno != EEXIST) {
 
988
                SYSERROR("failed with errno %d to create %s\n", errno, path);
 
989
                return -1;
 
990
        }
 
991
        INFO("created %s\n", path);
 
992
 
 
993
        ret = snprintf(lxcpath, sizeof(lxcpath), "%s/dev/%s/console",
 
994
                       rootfs->mount, ttydir);
 
995
        if (ret >= sizeof(lxcpath)) {
 
996
                ERROR("console path too long\n");
 
997
                return -1;
 
998
        }
 
999
 
 
1000
        snprintf(path, sizeof(path), "%s/dev/console", rootfs->mount);
 
1001
        ret = unlink(path);
 
1002
        if (ret && errno != ENOENT) {
 
1003
                SYSERROR("error unlinking %s\n", path);
 
1004
                return -1;
 
1005
        }
 
1006
 
 
1007
        ret = creat(lxcpath, 0660);
 
1008
        if (ret==-1 && errno != EEXIST) {
 
1009
                SYSERROR("error %d creating %s\n", errno, lxcpath);
 
1010
                return -1;
 
1011
        }
 
1012
        close(ret);
 
1013
 
 
1014
        if (console->peer == -1) {
 
1015
                INFO("no console output required");
 
1016
                return 0;
 
1017
        }
 
1018
 
 
1019
        if (mount(console->name, lxcpath, "none", MS_BIND, 0)) {
 
1020
                ERROR("failed to mount '%s' on '%s'", console->name, lxcpath);
 
1021
                return -1;
 
1022
        }
 
1023
 
 
1024
        /* create symlink from rootfs/dev/console to 'lxc/console' */
 
1025
        ret = snprintf(lxcpath, sizeof(lxcpath), "%s/console", ttydir);
 
1026
        if (ret >= sizeof(lxcpath)) {
 
1027
                ERROR("lxc/console path too long");
 
1028
                return -1;
 
1029
        }
 
1030
        ret = symlink(lxcpath, path);
 
1031
        if (ret) {
 
1032
                SYSERROR("failed to create symlink for console");
 
1033
                return -1;
 
1034
        }
 
1035
 
 
1036
        INFO("console has been setup on %s", lxcpath);
 
1037
 
 
1038
        return 0;
 
1039
}
 
1040
 
 
1041
static int setup_console(const struct lxc_rootfs *rootfs,
 
1042
                         const struct lxc_console *console,
 
1043
                         char *ttydir)
 
1044
{
 
1045
        /* We don't have a rootfs, /dev/console will be shared */
 
1046
        if (!rootfs->path)
 
1047
                return 0;
 
1048
        if (!ttydir)
 
1049
                return setup_dev_console(rootfs, console);
 
1050
 
 
1051
        return setup_ttydir_console(rootfs, console, ttydir);
 
1052
}
 
1053
 
 
1054
static int setup_cgroup(const char *name, struct lxc_list *cgroups)
 
1055
{
 
1056
        struct lxc_list *iterator;
 
1057
        struct lxc_cgroup *cg;
 
1058
        int ret = -1;
 
1059
 
 
1060
        if (lxc_list_empty(cgroups))
 
1061
                return 0;
 
1062
 
 
1063
        lxc_list_for_each(iterator, cgroups) {
 
1064
 
 
1065
                cg = iterator->elem;
 
1066
 
 
1067
                if (lxc_cgroup_set(name, cg->subsystem, cg->value))
 
1068
                        goto out;
 
1069
 
 
1070
                DEBUG("cgroup '%s' set to '%s'", cg->subsystem, cg->value);
 
1071
        }
 
1072
 
 
1073
        ret = 0;
 
1074
        INFO("cgroup has been setup");
 
1075
out:
 
1076
        return ret;
 
1077
}
 
1078
 
 
1079
static void parse_mntopt(char *opt, unsigned long *flags, char **data)
 
1080
{
 
1081
        struct mount_opt *mo;
 
1082
 
 
1083
        /* If opt is found in mount_opt, set or clear flags.
 
1084
         * Otherwise append it to data. */
 
1085
 
 
1086
        for (mo = &mount_opt[0]; mo->name != NULL; mo++) {
 
1087
                if (!strncmp(opt, mo->name, strlen(mo->name))) {
 
1088
                        if (mo->clear)
 
1089
                                *flags &= ~mo->flag;
 
1090
                        else
 
1091
                                *flags |= mo->flag;
 
1092
                        return;
 
1093
                }
 
1094
        }
 
1095
 
 
1096
        if (strlen(*data))
 
1097
                strcat(*data, ",");
 
1098
        strcat(*data, opt);
 
1099
}
 
1100
 
 
1101
static int parse_mntopts(const char *mntopts, unsigned long *mntflags,
 
1102
                         char **mntdata)
 
1103
{
 
1104
        char *s, *data;
 
1105
        char *p, *saveptr = NULL;
 
1106
 
 
1107
        *mntdata = NULL;
 
1108
        *mntflags = 0L;
 
1109
 
 
1110
        if (!mntopts)
 
1111
                return 0;
 
1112
 
 
1113
        s = strdup(mntopts);
 
1114
        if (!s) {
 
1115
                SYSERROR("failed to allocate memory");
 
1116
                return -1;
 
1117
        }
 
1118
 
 
1119
        data = malloc(strlen(s) + 1);
 
1120
        if (!data) {
 
1121
                SYSERROR("failed to allocate memory");
 
1122
                free(s);
 
1123
                return -1;
 
1124
        }
 
1125
        *data = 0;
 
1126
 
 
1127
        for (p = strtok_r(s, ",", &saveptr); p != NULL;
 
1128
             p = strtok_r(NULL, ",", &saveptr))
 
1129
                parse_mntopt(p, mntflags, &data);
 
1130
 
 
1131
        if (*data)
 
1132
                *mntdata = data;
 
1133
        else
 
1134
                free(data);
 
1135
        free(s);
 
1136
 
 
1137
        return 0;
 
1138
}
 
1139
 
 
1140
static int mount_entry(const char *fsname, const char *target,
 
1141
                       const char *fstype, unsigned long mountflags,
 
1142
                       const char *data)
 
1143
{
 
1144
        if (mount(fsname, target, fstype, mountflags & ~MS_REMOUNT, data)) {
 
1145
                SYSERROR("failed to mount '%s' on '%s'", fsname, target);
 
1146
                return -1;
 
1147
        }
 
1148
 
 
1149
        if ((mountflags & MS_REMOUNT) || (mountflags & MS_BIND)) {
 
1150
 
 
1151
                DEBUG("remounting %s on %s to respect bind or remount options",
 
1152
                      fsname, target);
 
1153
 
 
1154
                if (mount(fsname, target, fstype,
 
1155
                          mountflags | MS_REMOUNT, data)) {
 
1156
                        SYSERROR("failed to mount '%s' on '%s'",
 
1157
                                 fsname, target);
 
1158
                        return -1;
 
1159
                }
 
1160
        }
 
1161
 
 
1162
        DEBUG("mounted '%s' on '%s', type '%s'", fsname, target, fstype);
 
1163
 
 
1164
        return 0;
 
1165
}
 
1166
 
 
1167
static inline int mount_entry_on_systemfs(struct mntent *mntent)
 
1168
{
 
1169
        unsigned long mntflags;
 
1170
        char *mntdata;
 
1171
        int ret;
 
1172
 
 
1173
        if (parse_mntopts(mntent->mnt_opts, &mntflags, &mntdata) < 0) {
 
1174
                ERROR("failed to parse mount option '%s'", mntent->mnt_opts);
 
1175
                return -1;
 
1176
        }
 
1177
 
 
1178
        ret = mount_entry(mntent->mnt_fsname, mntent->mnt_dir,
 
1179
                          mntent->mnt_type, mntflags, mntdata);
 
1180
 
 
1181
        free(mntdata);
 
1182
 
 
1183
        return ret;
 
1184
}
 
1185
 
 
1186
static int mount_entry_on_absolute_rootfs(struct mntent *mntent,
 
1187
                                          const struct lxc_rootfs *rootfs,
 
1188
                                          const char *lxc_name)
 
1189
{
 
1190
        char *aux;
 
1191
        char path[MAXPATHLEN];
 
1192
        unsigned long mntflags;
 
1193
        char *mntdata;
 
1194
        int r, ret = 0, offset;
 
1195
 
 
1196
        if (parse_mntopts(mntent->mnt_opts, &mntflags, &mntdata) < 0) {
 
1197
                ERROR("failed to parse mount option '%s'", mntent->mnt_opts);
 
1198
                return -1;
 
1199
        }
 
1200
 
 
1201
        /* if rootfs->path is a blockdev path, allow container fstab to
 
1202
         * use /var/lib/lxc/CN/rootfs as the target prefix */
 
1203
        r = snprintf(path, MAXPATHLEN, "/var/lib/lxc/%s/rootfs", lxc_name);
 
1204
        if (r < 0 || r >= MAXPATHLEN)
 
1205
                goto skipvarlib;
 
1206
 
 
1207
        aux = strstr(mntent->mnt_dir, path);
 
1208
        if (aux) {
 
1209
                offset = strlen(path);
 
1210
                goto skipabs;
 
1211
        }
 
1212
 
 
1213
skipvarlib:
 
1214
        aux = strstr(mntent->mnt_dir, rootfs->path);
 
1215
        if (!aux) {
 
1216
                WARN("ignoring mount point '%s'", mntent->mnt_dir);
 
1217
                goto out;
 
1218
        }
 
1219
        offset = strlen(rootfs->path);
 
1220
 
 
1221
skipabs:
 
1222
 
 
1223
        r = snprintf(path, MAXPATHLEN, "%s/%s", rootfs->mount,
 
1224
                 aux + offset);
 
1225
        if (r < 0 || r >= MAXPATHLEN) {
 
1226
                WARN("pathnme too long for '%s'", mntent->mnt_dir);
 
1227
                ret = -1;
 
1228
                goto out;
 
1229
        }
 
1230
 
 
1231
 
 
1232
        ret = mount_entry(mntent->mnt_fsname, path, mntent->mnt_type,
 
1233
                          mntflags, mntdata);
 
1234
 
 
1235
out:
 
1236
        free(mntdata);
 
1237
        return ret;
 
1238
}
 
1239
 
 
1240
static int mount_entry_on_relative_rootfs(struct mntent *mntent,
 
1241
                                          const char *rootfs)
 
1242
{
 
1243
        char path[MAXPATHLEN];
 
1244
        unsigned long mntflags;
 
1245
        char *mntdata;
 
1246
        int ret;
 
1247
 
 
1248
        if (parse_mntopts(mntent->mnt_opts, &mntflags, &mntdata) < 0) {
 
1249
                ERROR("failed to parse mount option '%s'", mntent->mnt_opts);
 
1250
                return -1;
 
1251
        }
 
1252
 
 
1253
        /* relative to root mount point */
 
1254
        ret = snprintf(path, sizeof(path), "%s/%s", rootfs, mntent->mnt_dir);
 
1255
        if (ret >= sizeof(path)) {
 
1256
                ERROR("path name too long");
 
1257
                return -1;
 
1258
        }
 
1259
 
 
1260
        ret = mount_entry(mntent->mnt_fsname, path, mntent->mnt_type,
 
1261
                          mntflags, mntdata);
 
1262
 
 
1263
        free(mntdata);
 
1264
 
 
1265
        return ret;
 
1266
}
 
1267
 
 
1268
static int mount_file_entries(const struct lxc_rootfs *rootfs, FILE *file,
 
1269
        const char *lxc_name)
 
1270
{
 
1271
        struct mntent *mntent;
 
1272
        int ret = -1;
 
1273
 
 
1274
        while ((mntent = getmntent(file))) {
 
1275
 
 
1276
                if (!rootfs->path) {
 
1277
                        if (mount_entry_on_systemfs(mntent))
 
1278
                                goto out;
 
1279
                        continue;
 
1280
                }
 
1281
 
 
1282
                /* We have a separate root, mounts are relative to it */
 
1283
                if (mntent->mnt_dir[0] != '/') {
 
1284
                        if (mount_entry_on_relative_rootfs(mntent,
 
1285
                                                           rootfs->mount))
 
1286
                                goto out;
 
1287
                        continue;
 
1288
                }
 
1289
 
 
1290
                if (mount_entry_on_absolute_rootfs(mntent, rootfs, lxc_name))
 
1291
                        goto out;
 
1292
        }
 
1293
 
 
1294
        ret = 0;
 
1295
 
 
1296
        INFO("mount points have been setup");
 
1297
out:
 
1298
        return ret;
 
1299
}
 
1300
 
 
1301
static int setup_mount(const struct lxc_rootfs *rootfs, const char *fstab,
 
1302
        const char *lxc_name)
 
1303
{
 
1304
        FILE *file;
 
1305
        int ret;
 
1306
 
 
1307
        if (!fstab)
 
1308
                return 0;
 
1309
 
 
1310
        file = setmntent(fstab, "r");
 
1311
        if (!file) {
 
1312
                SYSERROR("failed to use '%s'", fstab);
 
1313
                return -1;
 
1314
        }
 
1315
 
 
1316
        ret = mount_file_entries(rootfs, file, lxc_name);
 
1317
 
 
1318
        endmntent(file);
 
1319
        return ret;
 
1320
}
 
1321
 
 
1322
static int setup_mount_entries(const struct lxc_rootfs *rootfs, struct lxc_list *mount,
 
1323
        const char *lxc_name)
 
1324
{
 
1325
        FILE *file;
 
1326
        struct lxc_list *iterator;
 
1327
        char *mount_entry;
 
1328
        int ret;
 
1329
 
 
1330
        file = tmpfile();
 
1331
        if (!file) {
 
1332
                ERROR("tmpfile error: %m");
 
1333
                return -1;
 
1334
        }
 
1335
 
 
1336
        lxc_list_for_each(iterator, mount) {
 
1337
                mount_entry = iterator->elem;
 
1338
                fprintf(file, "%s\n", mount_entry);
 
1339
        }
 
1340
 
 
1341
        rewind(file);
 
1342
 
 
1343
        ret = mount_file_entries(rootfs, file, lxc_name);
 
1344
 
 
1345
        fclose(file);
 
1346
        return ret;
 
1347
}
 
1348
 
 
1349
static int setup_caps(struct lxc_list *caps)
 
1350
{
 
1351
        struct lxc_list *iterator;
 
1352
        char *drop_entry;
 
1353
        char *ptr;
 
1354
        int i, capid;
 
1355
 
 
1356
        lxc_list_for_each(iterator, caps) {
 
1357
 
 
1358
                drop_entry = iterator->elem;
 
1359
 
 
1360
                capid = -1;
 
1361
 
 
1362
                for (i = 0; i < sizeof(caps_opt)/sizeof(caps_opt[0]); i++) {
 
1363
 
 
1364
                        if (strcmp(drop_entry, caps_opt[i].name))
 
1365
                                continue;
 
1366
 
 
1367
                        capid = caps_opt[i].value;
 
1368
                        break;
 
1369
                }
 
1370
 
 
1371
                if (capid < 0) {
 
1372
                        /* try to see if it's numeric, so the user may specify
 
1373
                        * capabilities  that the running kernel knows about but
 
1374
                        * we don't */
 
1375
                        capid = strtol(drop_entry, &ptr, 10);
 
1376
                        if (!ptr || *ptr != '\0' ||
 
1377
                        capid == LONG_MIN || capid == LONG_MAX)
 
1378
                                /* not a valid number */
 
1379
                                capid = -1;
 
1380
                        else if (capid > lxc_caps_last_cap())
 
1381
                                /* we have a number but it's not a valid
 
1382
                                * capability */
 
1383
                                capid = -1;
 
1384
                }
 
1385
 
 
1386
                if (capid < 0) {
 
1387
                        ERROR("unknown capability %s", drop_entry);
 
1388
                        return -1;
 
1389
                }
 
1390
 
 
1391
                DEBUG("drop capability '%s' (%d)", drop_entry, capid);
 
1392
 
 
1393
                if (prctl(PR_CAPBSET_DROP, capid, 0, 0, 0)) {
 
1394
                       SYSERROR("failed to remove %s capability", drop_entry);
 
1395
                       return -1;
 
1396
                }
 
1397
 
 
1398
        }
 
1399
 
 
1400
        DEBUG("capabilities has been setup");
 
1401
 
 
1402
        return 0;
 
1403
}
 
1404
 
 
1405
static int setup_hw_addr(char *hwaddr, const char *ifname)
 
1406
{
 
1407
        struct sockaddr sockaddr;
 
1408
        struct ifreq ifr;
 
1409
        int ret, fd;
 
1410
 
 
1411
        ret = lxc_convert_mac(hwaddr, &sockaddr);
 
1412
        if (ret) {
 
1413
                ERROR("mac address '%s' conversion failed : %s",
 
1414
                      hwaddr, strerror(-ret));
 
1415
                return -1;
 
1416
        }
 
1417
 
 
1418
        memcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 
1419
        memcpy((char *) &ifr.ifr_hwaddr, (char *) &sockaddr, sizeof(sockaddr));
 
1420
 
 
1421
        fd = socket(AF_INET, SOCK_DGRAM, 0);
 
1422
        if (fd < 0) {
 
1423
                ERROR("socket failure : %s", strerror(errno));
 
1424
                return -1;
 
1425
        }
 
1426
 
 
1427
        ret = ioctl(fd, SIOCSIFHWADDR, &ifr);
 
1428
        close(fd);
 
1429
        if (ret)
 
1430
                ERROR("ioctl failure : %s", strerror(errno));
 
1431
 
 
1432
        DEBUG("mac address '%s' on '%s' has been setup", hwaddr, ifname);
 
1433
 
 
1434
        return ret;
 
1435
}
 
1436
 
 
1437
static int setup_ipv4_addr(struct lxc_list *ip, int ifindex)
 
1438
{
 
1439
        struct lxc_list *iterator;
 
1440
        struct lxc_inetdev *inetdev;
 
1441
        int err;
 
1442
 
 
1443
        lxc_list_for_each(iterator, ip) {
 
1444
 
 
1445
                inetdev = iterator->elem;
 
1446
 
 
1447
                err = lxc_ipv4_addr_add(ifindex, &inetdev->addr,
 
1448
                                        &inetdev->bcast, inetdev->prefix);
 
1449
                if (err) {
 
1450
                        ERROR("failed to setup_ipv4_addr ifindex %d : %s",
 
1451
                              ifindex, strerror(-err));
 
1452
                        return -1;
 
1453
                }
 
1454
        }
 
1455
 
 
1456
        return 0;
 
1457
}
 
1458
 
 
1459
static int setup_ipv6_addr(struct lxc_list *ip, int ifindex)
 
1460
{
 
1461
        struct lxc_list *iterator;
 
1462
        struct lxc_inet6dev *inet6dev;
 
1463
        int err;
 
1464
 
 
1465
        lxc_list_for_each(iterator, ip) {
 
1466
 
 
1467
                inet6dev = iterator->elem;
 
1468
 
 
1469
                err = lxc_ipv6_addr_add(ifindex, &inet6dev->addr,
 
1470
                                        &inet6dev->mcast, &inet6dev->acast,
 
1471
                                        inet6dev->prefix);
 
1472
                if (err) {
 
1473
                        ERROR("failed to setup_ipv6_addr ifindex %d : %s",
 
1474
                              ifindex, strerror(-err));
 
1475
                        return -1;
 
1476
                }
 
1477
        }
 
1478
 
 
1479
        return 0;
 
1480
}
 
1481
 
 
1482
static int setup_netdev(struct lxc_netdev *netdev)
 
1483
{
 
1484
        char ifname[IFNAMSIZ];
 
1485
        char *current_ifname = ifname;
 
1486
        int err;
 
1487
 
 
1488
        /* empty network namespace */
 
1489
        if (!netdev->ifindex) {
 
1490
                if (netdev->flags & IFF_UP) {
 
1491
                        err = lxc_netdev_up("lo");
 
1492
                        if (err) {
 
1493
                                ERROR("failed to set the loopback up : %s",
 
1494
                                      strerror(-err));
 
1495
                                return -1;
 
1496
                        }
 
1497
                }
 
1498
                return 0;
 
1499
        }
 
1500
 
 
1501
        /* retrieve the name of the interface */
 
1502
        if (!if_indextoname(netdev->ifindex, current_ifname)) {
 
1503
                ERROR("no interface corresponding to index '%d'",
 
1504
                      netdev->ifindex);
 
1505
                return -1;
 
1506
        }
 
1507
 
 
1508
        /* default: let the system to choose one interface name */
 
1509
        if (!netdev->name)
 
1510
                netdev->name = netdev->type == LXC_NET_PHYS ?
 
1511
                        netdev->link : "eth%d";
 
1512
 
 
1513
        /* rename the interface name */
 
1514
        err = lxc_netdev_rename_by_name(ifname, netdev->name);
 
1515
        if (err) {
 
1516
                ERROR("failed to rename %s->%s : %s", ifname, netdev->name,
 
1517
                      strerror(-err));
 
1518
                return -1;
 
1519
        }
 
1520
 
 
1521
        /* Re-read the name of the interface because its name has changed
 
1522
         * and would be automatically allocated by the system
 
1523
         */
 
1524
        if (!if_indextoname(netdev->ifindex, current_ifname)) {
 
1525
                ERROR("no interface corresponding to index '%d'",
 
1526
                      netdev->ifindex);
 
1527
                return -1;
 
1528
        }
 
1529
 
 
1530
        /* set a mac address */
 
1531
        if (netdev->hwaddr) {
 
1532
                if (setup_hw_addr(netdev->hwaddr, current_ifname)) {
 
1533
                        ERROR("failed to setup hw address for '%s'",
 
1534
                              current_ifname);
 
1535
                        return -1;
 
1536
                }
 
1537
        }
 
1538
 
 
1539
        /* setup ipv4 addresses on the interface */
 
1540
        if (setup_ipv4_addr(&netdev->ipv4, netdev->ifindex)) {
 
1541
                ERROR("failed to setup ip addresses for '%s'",
 
1542
                              ifname);
 
1543
                return -1;
 
1544
        }
 
1545
 
 
1546
        /* setup ipv6 addresses on the interface */
 
1547
        if (setup_ipv6_addr(&netdev->ipv6, netdev->ifindex)) {
 
1548
                ERROR("failed to setup ipv6 addresses for '%s'",
 
1549
                              ifname);
 
1550
                return -1;
 
1551
        }
 
1552
 
 
1553
        /* set the network device up */
 
1554
        if (netdev->flags & IFF_UP) {
 
1555
                int err;
 
1556
 
 
1557
                err = lxc_netdev_up(current_ifname);
 
1558
                if (err) {
 
1559
                        ERROR("failed to set '%s' up : %s", current_ifname,
 
1560
                              strerror(-err));
 
1561
                        return -1;
 
1562
                }
 
1563
 
 
1564
                /* the network is up, make the loopback up too */
 
1565
                err = lxc_netdev_up("lo");
 
1566
                if (err) {
 
1567
                        ERROR("failed to set the loopback up : %s",
 
1568
                              strerror(-err));
 
1569
                        return -1;
 
1570
                }
 
1571
        }
 
1572
 
 
1573
        /* We can only set up the default routes after bringing
 
1574
         * up the interface, sine bringing up the interface adds
 
1575
         * the link-local routes and we can't add a default
 
1576
         * route if the gateway is not reachable. */
 
1577
 
 
1578
        /* setup ipv4 gateway on the interface */
 
1579
        if (netdev->ipv4_gateway) {
 
1580
                if (!(netdev->flags & IFF_UP)) {
 
1581
                        ERROR("Cannot add ipv4 gateway for %s when not bringing up the interface", ifname);
 
1582
                        return -1;
 
1583
                }
 
1584
 
 
1585
                if (lxc_list_empty(&netdev->ipv4)) {
 
1586
                        ERROR("Cannot add ipv4 gateway for %s when not assigning an address", ifname);
 
1587
                        return -1;
 
1588
                }
 
1589
 
 
1590
                err = lxc_ipv4_gateway_add(netdev->ifindex, netdev->ipv4_gateway);
 
1591
                if (err) {
 
1592
                        ERROR("failed to setup ipv4 gateway for '%s': %s",
 
1593
                                      ifname, strerror(-err));
 
1594
                        if (netdev->ipv4_gateway_auto) {
 
1595
                                char buf[INET_ADDRSTRLEN];
 
1596
                                inet_ntop(AF_INET, netdev->ipv4_gateway, buf, sizeof(buf));
 
1597
                                ERROR("tried to set autodetected ipv4 gateway '%s'", buf);
 
1598
                        }
 
1599
                        return -1;
 
1600
                }
 
1601
        }
 
1602
 
 
1603
        /* setup ipv6 gateway on the interface */
 
1604
        if (netdev->ipv6_gateway) {
 
1605
                if (!(netdev->flags & IFF_UP)) {
 
1606
                        ERROR("Cannot add ipv6 gateway for %s when not bringing up the interface", ifname);
 
1607
                        return -1;
 
1608
                }
 
1609
 
 
1610
                if (lxc_list_empty(&netdev->ipv6) && !IN6_IS_ADDR_LINKLOCAL(netdev->ipv6_gateway)) {
 
1611
                        ERROR("Cannot add ipv6 gateway for %s when not assigning an address", ifname);
 
1612
                        return -1;
 
1613
                }
 
1614
 
 
1615
                err = lxc_ipv6_gateway_add(netdev->ifindex, netdev->ipv6_gateway);
 
1616
                if (err) {
 
1617
                        ERROR("failed to setup ipv6 gateway for '%s': %s",
 
1618
                                      ifname, strerror(-err));
 
1619
                        if (netdev->ipv6_gateway_auto) {
 
1620
                                char buf[INET6_ADDRSTRLEN];
 
1621
                                inet_ntop(AF_INET, netdev->ipv6_gateway, buf, sizeof(buf));
 
1622
                                ERROR("tried to set autodetected ipv6 gateway '%s'", buf);
 
1623
                        }
 
1624
                        return -1;
 
1625
                }
 
1626
        }
 
1627
 
 
1628
        DEBUG("'%s' has been setup", current_ifname);
 
1629
 
 
1630
        return 0;
 
1631
}
 
1632
 
 
1633
static int setup_network(struct lxc_list *network)
 
1634
{
 
1635
        struct lxc_list *iterator;
 
1636
        struct lxc_netdev *netdev;
 
1637
 
 
1638
        lxc_list_for_each(iterator, network) {
 
1639
 
 
1640
                netdev = iterator->elem;
 
1641
 
 
1642
                if (setup_netdev(netdev)) {
 
1643
                        ERROR("failed to setup netdev");
 
1644
                        return -1;
 
1645
                }
 
1646
        }
 
1647
 
 
1648
        if (!lxc_list_empty(network))
 
1649
                INFO("network has been setup");
 
1650
 
 
1651
        return 0;
 
1652
}
 
1653
 
 
1654
static int setup_private_host_hw_addr(char *veth1)
 
1655
{
 
1656
        struct ifreq ifr;
 
1657
        int err;
 
1658
        int sockfd;
 
1659
 
 
1660
        sockfd = socket(AF_INET, SOCK_DGRAM, 0);
 
1661
        if (sockfd < 0)
 
1662
                return -errno;
 
1663
 
 
1664
        snprintf((char *)ifr.ifr_name, IFNAMSIZ, "%s", veth1);
 
1665
        err = ioctl(sockfd, SIOCGIFHWADDR, &ifr);
 
1666
        if (err < 0) {
 
1667
                close(sockfd);
 
1668
                return -errno;
 
1669
        }
 
1670
 
 
1671
        ifr.ifr_hwaddr.sa_data[0] = 0xfe;
 
1672
        err = ioctl(sockfd, SIOCSIFHWADDR, &ifr);
 
1673
        close(sockfd);
 
1674
        if (err < 0)
 
1675
                return -errno;
 
1676
 
 
1677
        DEBUG("mac address of host interface '%s' changed to private "
 
1678
              "%02x:%02x:%02x:%02x:%02x:%02x", veth1,
 
1679
              ifr.ifr_hwaddr.sa_data[0] & 0xff,
 
1680
              ifr.ifr_hwaddr.sa_data[1] & 0xff,
 
1681
              ifr.ifr_hwaddr.sa_data[2] & 0xff,
 
1682
              ifr.ifr_hwaddr.sa_data[3] & 0xff,
 
1683
              ifr.ifr_hwaddr.sa_data[4] & 0xff,
 
1684
              ifr.ifr_hwaddr.sa_data[5] & 0xff);
 
1685
 
 
1686
        return 0;
 
1687
}
 
1688
 
 
1689
struct lxc_conf *lxc_conf_init(void)
 
1690
{
 
1691
        struct lxc_conf *new;
 
1692
 
 
1693
        new =   malloc(sizeof(*new));
 
1694
        if (!new) {
 
1695
                ERROR("lxc_conf_init : %m");
 
1696
                return NULL;
 
1697
        }
 
1698
        memset(new, 0, sizeof(*new));
 
1699
 
 
1700
        new->umount_proc = 0;
 
1701
        new->personality = -1;
 
1702
        new->console.path = NULL;
 
1703
        new->console.peer = -1;
 
1704
        new->console.master = -1;
 
1705
        new->console.slave = -1;
 
1706
        new->console.name[0] = '\0';
 
1707
        new->rootfs.mount = LXCROOTFSMOUNT;
 
1708
        lxc_list_init(&new->cgroup);
 
1709
        lxc_list_init(&new->network);
 
1710
        lxc_list_init(&new->mount_list);
 
1711
        lxc_list_init(&new->caps);
 
1712
        new->aa_profile = NULL;
 
1713
 
 
1714
        return new;
 
1715
}
 
1716
 
 
1717
static int instanciate_veth(struct lxc_handler *handler, struct lxc_netdev *netdev)
 
1718
{
 
1719
        char veth1buf[IFNAMSIZ], *veth1;
 
1720
        char veth2buf[IFNAMSIZ], *veth2;
 
1721
        int err;
 
1722
 
 
1723
        if (netdev->priv.veth_attr.pair)
 
1724
                veth1 = netdev->priv.veth_attr.pair;
 
1725
        else {
 
1726
                err = snprintf(veth1buf, sizeof(veth1buf), "vethXXXXXX");
 
1727
                if (err >= sizeof(veth1buf)) { /* can't *really* happen, but... */
 
1728
                        ERROR("veth1 name too long");
 
1729
                        return -1;
 
1730
                }
 
1731
                veth1 = mktemp(veth1buf);
 
1732
        }
 
1733
 
 
1734
        snprintf(veth2buf, sizeof(veth2buf), "vethXXXXXX");
 
1735
        veth2 = mktemp(veth2buf);
 
1736
 
 
1737
        if (!strlen(veth1) || !strlen(veth2)) {
 
1738
                ERROR("failed to allocate a temporary name");
 
1739
                return -1;
 
1740
        }
 
1741
 
 
1742
        err = lxc_veth_create(veth1, veth2);
 
1743
        if (err) {
 
1744
                ERROR("failed to create %s-%s : %s", veth1, veth2,
 
1745
                      strerror(-err));
 
1746
                return -1;
 
1747
        }
 
1748
 
 
1749
        /* changing the high byte of the mac address to 0xfe, the bridge interface
 
1750
         * will always keep the host's mac address and not take the mac address
 
1751
         * of a container */
 
1752
        err = setup_private_host_hw_addr(veth1);
 
1753
        if (err) {
 
1754
                ERROR("failed to change mac address of host interface '%s' : %s",
 
1755
                        veth1, strerror(-err));
 
1756
                goto out_delete;
 
1757
        }
 
1758
 
 
1759
        if (netdev->mtu) {
 
1760
                err = lxc_netdev_set_mtu(veth1, atoi(netdev->mtu));
 
1761
                if (!err)
 
1762
                        err = lxc_netdev_set_mtu(veth2, atoi(netdev->mtu));
 
1763
                if (err) {
 
1764
                        ERROR("failed to set mtu '%s' for %s-%s : %s",
 
1765
                              netdev->mtu, veth1, veth2, strerror(-err));
 
1766
                        goto out_delete;
 
1767
                }
 
1768
        }
 
1769
 
 
1770
        if (netdev->link) {
 
1771
                err = lxc_bridge_attach(netdev->link, veth1);
 
1772
                if (err) {
 
1773
                        ERROR("failed to attach '%s' to the bridge '%s' : %s",
 
1774
                                      veth1, netdev->link, strerror(-err));
 
1775
                        goto out_delete;
 
1776
                }
 
1777
        }
 
1778
 
 
1779
        netdev->ifindex = if_nametoindex(veth2);
 
1780
        if (!netdev->ifindex) {
 
1781
                ERROR("failed to retrieve the index for %s", veth2);
 
1782
                goto out_delete;
 
1783
        }
 
1784
 
 
1785
        err = lxc_netdev_up(veth1);
 
1786
        if (err) {
 
1787
                ERROR("failed to set %s up : %s", veth1, strerror(-err));
 
1788
                goto out_delete;
 
1789
        }
 
1790
 
 
1791
        if (netdev->upscript) {
 
1792
                err = run_script(handler->name, "net", netdev->upscript, "up",
 
1793
                                 "veth", veth1, (char*) NULL);
 
1794
                if (err)
 
1795
                        goto out_delete;
 
1796
        }
 
1797
 
 
1798
        DEBUG("instanciated veth '%s/%s', index is '%d'",
 
1799
              veth1, veth2, netdev->ifindex);
 
1800
 
 
1801
        return 0;
 
1802
 
 
1803
out_delete:
 
1804
        lxc_netdev_delete_by_name(veth1);
 
1805
        return -1;
 
1806
}
 
1807
 
 
1808
static int instanciate_macvlan(struct lxc_handler *handler, struct lxc_netdev *netdev)
 
1809
{
 
1810
        char peerbuf[IFNAMSIZ], *peer;
 
1811
        int err;
 
1812
 
 
1813
        if (!netdev->link) {
 
1814
                ERROR("no link specified for macvlan netdev");
 
1815
                return -1;
 
1816
        }
 
1817
 
 
1818
        err = snprintf(peerbuf, sizeof(peerbuf), "mcXXXXXX");
 
1819
        if (err >= sizeof(peerbuf))
 
1820
                return -1;
 
1821
 
 
1822
        peer = mktemp(peerbuf);
 
1823
        if (!strlen(peer)) {
 
1824
                ERROR("failed to make a temporary name");
 
1825
                return -1;
 
1826
        }
 
1827
 
 
1828
        err = lxc_macvlan_create(netdev->link, peer,
 
1829
                                 netdev->priv.macvlan_attr.mode);
 
1830
        if (err) {
 
1831
                ERROR("failed to create macvlan interface '%s' on '%s' : %s",
 
1832
                      peer, netdev->link, strerror(-err));
 
1833
                return -1;
 
1834
        }
 
1835
 
 
1836
        netdev->ifindex = if_nametoindex(peer);
 
1837
        if (!netdev->ifindex) {
 
1838
                ERROR("failed to retrieve the index for %s", peer);
 
1839
                lxc_netdev_delete_by_name(peer);
 
1840
                return -1;
 
1841
        }
 
1842
 
 
1843
        if (netdev->upscript) {
 
1844
                err = run_script(handler->name, "net", netdev->upscript, "up",
 
1845
                                 "macvlan", netdev->link, (char*) NULL);
 
1846
                if (err)
 
1847
                        return -1;
 
1848
        }
 
1849
 
 
1850
        DEBUG("instanciated macvlan '%s', index is '%d' and mode '%d'",
 
1851
              peer, netdev->ifindex, netdev->priv.macvlan_attr.mode);
 
1852
 
 
1853
        return 0;
 
1854
}
 
1855
 
 
1856
/* XXX: merge with instanciate_macvlan */
 
1857
static int instanciate_vlan(struct lxc_handler *handler, struct lxc_netdev *netdev)
 
1858
{
 
1859
        char peer[IFNAMSIZ];
 
1860
        int err;
 
1861
 
 
1862
        if (!netdev->link) {
 
1863
                ERROR("no link specified for vlan netdev");
 
1864
                return -1;
 
1865
        }
 
1866
 
 
1867
        err = snprintf(peer, sizeof(peer), "vlan%d", netdev->priv.vlan_attr.vid);
 
1868
        if (err >= sizeof(peer)) {
 
1869
                ERROR("peer name too long");
 
1870
                return -1;
 
1871
        }
 
1872
 
 
1873
        err = lxc_vlan_create(netdev->link, peer, netdev->priv.vlan_attr.vid);
 
1874
        if (err) {
 
1875
                ERROR("failed to create vlan interface '%s' on '%s' : %s",
 
1876
                      peer, netdev->link, strerror(-err));
 
1877
                return -1;
 
1878
        }
 
1879
 
 
1880
        netdev->ifindex = if_nametoindex(peer);
 
1881
        if (!netdev->ifindex) {
 
1882
                ERROR("failed to retrieve the ifindex for %s", peer);
 
1883
                lxc_netdev_delete_by_name(peer);
 
1884
                return -1;
 
1885
        }
 
1886
 
 
1887
        DEBUG("instanciated vlan '%s', ifindex is '%d'", " vlan1000",
 
1888
              netdev->ifindex);
 
1889
 
 
1890
        return 0;
 
1891
}
 
1892
 
 
1893
static int instanciate_phys(struct lxc_handler *handler, struct lxc_netdev *netdev)
 
1894
{
 
1895
        if (!netdev->link) {
 
1896
                ERROR("no link specified for the physical interface");
 
1897
                return -1;
 
1898
        }
 
1899
 
 
1900
        netdev->ifindex = if_nametoindex(netdev->link);
 
1901
        if (!netdev->ifindex) {
 
1902
                ERROR("failed to retrieve the index for %s", netdev->link);
 
1903
                return -1;
 
1904
        }
 
1905
 
 
1906
        if (netdev->upscript) {
 
1907
                int err;
 
1908
                err = run_script(handler->name, "net", netdev->upscript,
 
1909
                                 "up", "phys", netdev->link, (char*) NULL);
 
1910
                if (err)
 
1911
                        return -1;
 
1912
        }
 
1913
 
 
1914
        return 0;
 
1915
}
 
1916
 
 
1917
static int instanciate_empty(struct lxc_handler *handler, struct lxc_netdev *netdev)
 
1918
{
 
1919
        netdev->ifindex = 0;
 
1920
        if (netdev->upscript) {
 
1921
                int err;
 
1922
                err = run_script(handler->name, "net", netdev->upscript,
 
1923
                                 "up", "empty", (char*) NULL);
 
1924
                if (err)
 
1925
                        return -1;
 
1926
        }
 
1927
        return 0;
 
1928
}
 
1929
 
 
1930
int lxc_create_network(struct lxc_handler *handler)
 
1931
{
 
1932
        struct lxc_list *network = &handler->conf->network;
 
1933
        struct lxc_list *iterator;
 
1934
        struct lxc_netdev *netdev;
 
1935
 
 
1936
        lxc_list_for_each(iterator, network) {
 
1937
 
 
1938
                netdev = iterator->elem;
 
1939
 
 
1940
                if (netdev->type < 0 || netdev->type > LXC_NET_MAXCONFTYPE) {
 
1941
                        ERROR("invalid network configuration type '%d'",
 
1942
                              netdev->type);
 
1943
                        return -1;
 
1944
                }
 
1945
 
 
1946
                if (netdev_conf[netdev->type](handler, netdev)) {
 
1947
                        ERROR("failed to create netdev");
 
1948
                        return -1;
 
1949
                }
 
1950
 
 
1951
        }
 
1952
 
 
1953
        return 0;
 
1954
}
 
1955
 
 
1956
void lxc_delete_network(struct lxc_list *network)
 
1957
{
 
1958
        struct lxc_list *iterator;
 
1959
        struct lxc_netdev *netdev;
 
1960
 
 
1961
        lxc_list_for_each(iterator, network) {
 
1962
                netdev = iterator->elem;
 
1963
                if (netdev->ifindex == 0)
 
1964
                        continue;
 
1965
 
 
1966
                if (netdev->type == LXC_NET_PHYS) {
 
1967
                        if (lxc_netdev_rename_by_index(netdev->ifindex, netdev->link))
 
1968
                                WARN("failed to rename to the initial name the " \
 
1969
                                     "netdev '%s'", netdev->link);
 
1970
                        continue;
 
1971
                }
 
1972
 
 
1973
                /* Recent kernel remove the virtual interfaces when the network
 
1974
                 * namespace is destroyed but in case we did not moved the
 
1975
                 * interface to the network namespace, we have to destroy it
 
1976
                 */
 
1977
                if (lxc_netdev_delete_by_index(netdev->ifindex))
 
1978
                        WARN("failed to remove interface '%s'", netdev->name);
 
1979
        }
 
1980
}
 
1981
 
 
1982
int lxc_assign_network(struct lxc_list *network, pid_t pid)
 
1983
{
 
1984
        struct lxc_list *iterator;
 
1985
        struct lxc_netdev *netdev;
 
1986
        int err;
 
1987
 
 
1988
        lxc_list_for_each(iterator, network) {
 
1989
 
 
1990
                netdev = iterator->elem;
 
1991
 
 
1992
                /* empty network namespace, nothing to move */
 
1993
                if (!netdev->ifindex)
 
1994
                        continue;
 
1995
 
 
1996
                err = lxc_netdev_move_by_index(netdev->ifindex, pid);
 
1997
                if (err) {
 
1998
                        ERROR("failed to move '%s' to the container : %s",
 
1999
                              netdev->link, strerror(-err));
 
2000
                        return -1;
 
2001
                }
 
2002
 
 
2003
                DEBUG("move '%s' to '%d'", netdev->name, pid);
 
2004
        }
 
2005
 
 
2006
        return 0;
 
2007
}
 
2008
 
 
2009
int lxc_find_gateway_addresses(struct lxc_handler *handler)
 
2010
{
 
2011
        struct lxc_list *network = &handler->conf->network;
 
2012
        struct lxc_list *iterator;
 
2013
        struct lxc_netdev *netdev;
 
2014
        int link_index;
 
2015
 
 
2016
        lxc_list_for_each(iterator, network) {
 
2017
                netdev = iterator->elem;
 
2018
 
 
2019
                if (!netdev->ipv4_gateway_auto && !netdev->ipv6_gateway_auto)
 
2020
                        continue;
 
2021
 
 
2022
                if (netdev->type != LXC_NET_VETH && netdev->type != LXC_NET_MACVLAN) {
 
2023
                        ERROR("gateway = auto only supported for "
 
2024
                              "veth and macvlan");
 
2025
                        return -1;
 
2026
                }
 
2027
 
 
2028
                if (!netdev->link) {
 
2029
                        ERROR("gateway = auto needs a link interface");
 
2030
                        return -1;
 
2031
                }
 
2032
 
 
2033
                link_index = if_nametoindex(netdev->link);
 
2034
                if (!link_index)
 
2035
                        return -EINVAL;
 
2036
 
 
2037
                if (netdev->ipv4_gateway_auto) {
 
2038
                        if (lxc_ipv4_addr_get(link_index, &netdev->ipv4_gateway)) {
 
2039
                                ERROR("failed to automatically find ipv4 gateway "
 
2040
                                      "address from link interface '%s'", netdev->link);
 
2041
                                return -1;
 
2042
                        }
 
2043
                }
 
2044
 
 
2045
                if (netdev->ipv6_gateway_auto) {
 
2046
                        if (lxc_ipv6_addr_get(link_index, &netdev->ipv6_gateway)) {
 
2047
                                ERROR("failed to automatically find ipv6 gateway "
 
2048
                                      "address from link interface '%s'", netdev->link);
 
2049
                                return -1;
 
2050
                        }
 
2051
                }
 
2052
        }
 
2053
 
 
2054
        return 0;
 
2055
}
 
2056
 
 
2057
int lxc_create_tty(const char *name, struct lxc_conf *conf)
 
2058
{
 
2059
        struct lxc_tty_info *tty_info = &conf->tty_info;
 
2060
        int i;
 
2061
 
 
2062
        /* no tty in the configuration */
 
2063
        if (!conf->tty)
 
2064
                return 0;
 
2065
 
 
2066
        tty_info->pty_info =
 
2067
                malloc(sizeof(*tty_info->pty_info)*conf->tty);
 
2068
        if (!tty_info->pty_info) {
 
2069
                SYSERROR("failed to allocate pty_info");
 
2070
                return -1;
 
2071
        }
 
2072
 
 
2073
        for (i = 0; i < conf->tty; i++) {
 
2074
 
 
2075
                struct lxc_pty_info *pty_info = &tty_info->pty_info[i];
 
2076
 
 
2077
                if (openpty(&pty_info->master, &pty_info->slave,
 
2078
                            pty_info->name, NULL, NULL)) {
 
2079
                        SYSERROR("failed to create pty #%d", i);
 
2080
                        tty_info->nbtty = i;
 
2081
                        lxc_delete_tty(tty_info);
 
2082
                        return -1;
 
2083
                }
 
2084
 
 
2085
                DEBUG("allocated pty '%s' (%d/%d)",
 
2086
                      pty_info->name, pty_info->master, pty_info->slave);
 
2087
 
 
2088
                /* Prevent leaking the file descriptors to the container */
 
2089
                fcntl(pty_info->master, F_SETFD, FD_CLOEXEC);
 
2090
                fcntl(pty_info->slave, F_SETFD, FD_CLOEXEC);
 
2091
 
 
2092
                pty_info->busy = 0;
 
2093
        }
 
2094
 
 
2095
        tty_info->nbtty = conf->tty;
 
2096
 
 
2097
        INFO("tty's configured");
 
2098
 
 
2099
        return 0;
 
2100
}
 
2101
 
 
2102
void lxc_delete_tty(struct lxc_tty_info *tty_info)
 
2103
{
 
2104
        int i;
 
2105
 
 
2106
        for (i = 0; i < tty_info->nbtty; i++) {
 
2107
                struct lxc_pty_info *pty_info = &tty_info->pty_info[i];
 
2108
 
 
2109
                close(pty_info->master);
 
2110
                close(pty_info->slave);
 
2111
        }
 
2112
 
 
2113
        free(tty_info->pty_info);
 
2114
        tty_info->nbtty = 0;
 
2115
}
 
2116
 
 
2117
/*
 
2118
 * make sure /proc/self exists, and points to '1', since we are the
 
2119
 * container init.
 
2120
 * Else mount /proc.  Return 0 if proc was
 
2121
 * already mounted, 1 if we mounted it, -1 if we failed.
 
2122
 */
 
2123
static int mount_proc_if_needed(char *root_src, char *rootfs_tgt)
 
2124
{
 
2125
        char path[MAXPATHLEN];
 
2126
        char link[20];
 
2127
        int linklen, ret;
 
2128
 
 
2129
        ret = snprintf(path, MAXPATHLEN, "%s/proc/self", root_src ? rootfs_tgt : "");
 
2130
        if (ret < 0 || ret >= MAXPATHLEN) {
 
2131
                SYSERROR("proc path name too long");
 
2132
                return -1;
 
2133
        }
 
2134
        memset(link, 0, 20);
 
2135
        linklen = readlink(path, link, 20);
 
2136
        INFO("I am %d, /proc/self points to %s\n", getpid(), link);
 
2137
        ret = snprintf(path, MAXPATHLEN, "%s/proc", root_src ? rootfs_tgt : "");
 
2138
        if (linklen < 0) /* /proc not mounted */
 
2139
                goto domount;
 
2140
        /* can't be longer than rootfs/proc/1 */
 
2141
        if (strncmp(link, "1", linklen) != 0) {
 
2142
                /* wrong /procs mounted */
 
2143
                umount2(path, MNT_DETACH); /* ignore failure */
 
2144
                goto domount;
 
2145
        }
 
2146
        /* the right proc is already mounted */
 
2147
        return 0;
 
2148
 
 
2149
domount:
 
2150
        if (mount("proc", path, "proc", 0, NULL))
 
2151
                return -1;
 
2152
        INFO("Mounted /proc for the container\n");
 
2153
        return 1;
 
2154
}
 
2155
 
 
2156
int lxc_setup(const char *name, struct lxc_conf *lxc_conf)
 
2157
{
 
2158
        int mounted;
 
2159
 
 
2160
        if (setup_utsname(lxc_conf->utsname)) {
 
2161
                ERROR("failed to setup the utsname for '%s'", name);
 
2162
                return -1;
 
2163
        }
 
2164
 
 
2165
        if (setup_network(&lxc_conf->network)) {
 
2166
                ERROR("failed to setup the network for '%s'", name);
 
2167
                return -1;
 
2168
        }
 
2169
 
 
2170
        if (setup_rootfs(&lxc_conf->rootfs)) {
 
2171
                ERROR("failed to setup rootfs for '%s'", name);
 
2172
                return -1;
 
2173
        }
 
2174
 
 
2175
        if (setup_mount(&lxc_conf->rootfs, lxc_conf->fstab, name)) {
 
2176
                ERROR("failed to setup the mounts for '%s'", name);
 
2177
                return -1;
 
2178
        }
 
2179
 
 
2180
        if (setup_mount_entries(&lxc_conf->rootfs, &lxc_conf->mount_list, name)) {
 
2181
                ERROR("failed to setup the mount entries for '%s'", name);
 
2182
                return -1;
 
2183
        }
 
2184
 
 
2185
        if (setup_cgroup(name, &lxc_conf->cgroup)) {
 
2186
                ERROR("failed to setup the cgroups for '%s'", name);
 
2187
                return -1;
 
2188
        }
 
2189
 
 
2190
        if (setup_console(&lxc_conf->rootfs, &lxc_conf->console, lxc_conf->ttydir)) {
 
2191
                ERROR("failed to setup the console for '%s'", name);
 
2192
                return -1;
 
2193
        }
 
2194
 
 
2195
        if (setup_tty(&lxc_conf->rootfs, &lxc_conf->tty_info, lxc_conf->ttydir)) {
 
2196
                ERROR("failed to setup the ttys for '%s'", name);
 
2197
                return -1;
 
2198
        }
 
2199
 
 
2200
        /* aa_change_onexec makes more sense since we want to transition when
 
2201
         * /sbin/init is exec'd.  But the transitions doesn't seem to work
 
2202
         * then (refused).  aa_change_onexec will work since we're doing it
 
2203
         * right before the exec, so we'll just use that for now.
 
2204
         * In case the container fstab didn't mount /proc, we mount it.
 
2205
         */
 
2206
        INFO("rootfs path is .%s., mount is .%s.", lxc_conf->rootfs.path,
 
2207
                lxc_conf->rootfs.mount);
 
2208
 
 
2209
        mounted = mount_proc_if_needed(lxc_conf->rootfs.path, lxc_conf->rootfs.mount);
 
2210
        if (mounted == -1) {
 
2211
                SYSERROR("failed to mount /proc in the container.");
 
2212
                return -1;
 
2213
        } else if (mounted == 1) {
 
2214
                lxc_conf->umount_proc = 1;
 
2215
        }
 
2216
 
 
2217
        if (setup_pivot_root(&lxc_conf->rootfs)) {
 
2218
                ERROR("failed to set rootfs for '%s'", name);
 
2219
                return -1;
 
2220
        }
 
2221
 
 
2222
        if (setup_pts(lxc_conf->pts)) {
 
2223
                ERROR("failed to setup the new pts instance");
 
2224
                return -1;
 
2225
        }
 
2226
 
 
2227
        if (setup_personality(lxc_conf->personality)) {
 
2228
                ERROR("failed to setup personality");
 
2229
                return -1;
 
2230
        }
 
2231
 
 
2232
        if (setup_caps(&lxc_conf->caps)) {
 
2233
                ERROR("failed to drop capabilities");
 
2234
                return -1;
 
2235
        }
 
2236
 
 
2237
        NOTICE("'%s' is setup.", name);
 
2238
 
 
2239
        return 0;
 
2240
}