← Back to branch summary

~upstart-devel/upstart/upstart-jobs

« back to all changes in this revision

Viewing changes to vivid/etc/init.d/vz

  • Committer: Dimitri John Ledkov
  • Date: 2014-11-19 12:58:41 UTC
  • Revision ID: dimitri.j.ledkov@intel.com-20141119125841-98dr37roy8dvcv3b
auto update

Show diffs side-by-side

added added

removed removed

Lines of Context:
vivid/etc/init.d/vz
 
1
#!/bin/sh
 
2
#  Copyright (C) 2000-2009, Parallels, Inc. All rights reserved.
 
3
#
 
4
#  This program is free software; you can redistribute it and/or modify
 
5
#  it under the terms of the GNU General Public License as published by
 
6
#  the Free Software Foundation; either version 2 of the License, or
 
7
#  (at your option) any later version.
 
8
#
 
9
#  This program is distributed in the hope that it will be useful,
 
10
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
#  GNU General Public License for more details.
 
13
#
 
14
#  You should have received a copy of the GNU General Public License
 
15
#  along with this program; if not, write to the Free Software
 
16
#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
#
 
18
#
 
19
# OpenVZ startup script, used for redhat and debian related distributions.
 
20
 
 
21
###
 
22
# chkconfig: 2345 96 20
 
23
# description: OpenVZ startup script.
 
24
###
 
25
 
 
26
### BEGIN INIT INFO
 
27
# Provides: vz
 
28
# Required-start: $network $remote_fs $syslog
 
29
# Required-stop:  $network $remote_fs $syslog
 
30
# Should-Start:  sshd vzeventd
 
31
# Should-Stop:  sshd vzeventd
 
32
# Default-Start: 2 3 4 5
 
33
# Default-Stop: 0 1 6
 
34
# Short-Description: OpenVZ startup script
 
35
# Description: OpenVZ startup script.
 
36
### END INIT INFO
 
37
 
 
38
 
 
39
# This line is needed to cheat /etc/init.d/rc who expects action word
 
40
 
 
41
. /usr/lib/vzctl/vzctl/scripts/initd-functions
 
42
 
 
43
VZQUOTA=/usr/sbin/vzquota
 
44
CONFIG_DIR=/etc/vz/conf
 
45
VZREBOOTDIR=/var/lib/vzctl/vzreboot
 
46
LOCKFILE=$VARLOCK/vz_lock
 
47
SUBSYS_VZ=$VARLOCK/vz
 
48
VESTAT=/proc/vz/vestat
 
49
VZDEV=venet0
 
50
PRELOAD_MODULES=
 
51
MODULES=
 
52
MODULES_OTHER=
 
53
NET_MODULES=
 
54
IPT_MODULES=
 
55
 
 
56
if [ "${MODULES_DISABLED}" != "yes" ]; then
 
57
        PRELOAD_MODULES="af_packet"
 
58
        MODULES="vzmon vzdquota vzdev"
 
59
        CPT_MODULES="vzcpt vzrst"
 
60
        MODULES_OTHER="vzcompat vziolimit ${CPT_MODULES}"
 
61
        VNET_MODULES="vznetdev vznet"
 
62
        VETH_MODULES="vzethdev"
 
63
        NET_MODULES="${VNET_MODULES} ${VETH_MODULES}"
 
64
        if [ "${VZWDOG}" = "yes" ]; then
 
65
                MODULES="${MODULES} vzwdog"
 
66
        fi
 
67
        if [ -z "$IPTABLES_MODULES" ]; then
 
68
                if [ -n "$IPTABLES" ]; then
 
69
                        echo "WARNING: IPTABLES in vz.conf is obsoleted, " 1>&2
 
70
                        echo "please use IPTABLES_MODULES instead" 1>&2
 
71
                        IPTABLES_MODULES="$IPTABLES"
 
72
                fi
 
73
        fi
 
74
        IPT_MODULES="ip_tables ${IPTABLES_MODULES} xt_tcpudp"
 
75
        if [ "${IPV6}" = "yes" ]; then
 
76
                IPT_MODULES="${IPT_MODULES} ${IP6TABLES}"
 
77
        fi
 
78
        VZFS_MODULES="simfs"
 
79
        PLOOP_MODULES="ploop pfmt_ploop1 pfmt_raw pio_direct pio_nfs"
 
80
fi
 
81
 
 
82
 
 
83
VEINFO=""
 
84
RETVAL=0
 
85
cd /
 
86
 
 
87
get_kernel_version()
 
88
{
 
89
        [ ! -z "$KERNEL_MAJOR" ] && return
 
90
 
 
91
        local ver=$(uname -r)
 
92
        local kernel=$(echo $ver | sed s/[-+].*//)
 
93
        KERNEL_MAJOR=$(echo $kernel | awk -F . '{print $1}')
 
94
        KERNEL_MINOR=$(echo $kernel | awk -F . '{print $2}')
 
95
        KERNEL_PATCHLEVEL=$(echo $kernel | awk -F . '{print $3}')
 
96
}
 
97
 
 
98
check_kernel_config()
 
99
{
 
100
        test -r /proc/config.gz || return 0
 
101
 
 
102
        local conf opt err=0
 
103
        local opt_must="SIM_FS VE VE_CALLS VZ_GENCALLS"
 
104
        get_kernel_version
 
105
        # For kernels >= 2.6.9 VZ_DEV must be set.
 
106
        test "${KERNEL_MINOR}" -ge 6 &&
 
107
                test "${KERNEL_PATCHLEVEL}" -gt 9 &&
 
108
                        opt_must="${opt_must} VZ_DEV"
 
109
#       local opt_rec="SCHED_VCPU FAIRSCHED VZ_QUOTA VZ_QUOTA_UGID VE_NETDEV VE_ETHDEV
 
110
#                       VE_IPTABLES VZ_CHECKPOINT VZ_WDOG"
 
111
 
 
112
        conf="`zcat /proc/config.gz 2>/dev/null | grep -E -v '^#|^$'`"
 
113
 
 
114
        for opt in $opt_must; do
 
115
                if ! echo "$conf" 2>/dev/null | grep -q "$opt="; then
 
116
                        echo "ERROR: Missing kernel config option: CONFIG_$opt"
 
117
                        err=1
 
118
                fi
 
119
        done
 
120
        if [ $err != 0 ]; then
 
121
                print_failure "Please recompile your kernel."
 
122
                exit 1
 
123
        fi
 
124
}
 
125
 
 
126
mount_cgroups()
 
127
{
 
128
        local g
 
129
        for g in beancounter container fairsched ; do
 
130
                if [ -d /proc/vz/$g ]; then
 
131
                        mount -t cgroup $g /proc/vz/$g -o name=$g 2>/dev/null
 
132
                fi
 
133
        done
 
134
}
 
135
 
 
136
umount_cgroups()
 
137
{
 
138
        local g
 
139
        for g in beancounter container fairsched ; do
 
140
                umount /proc/vz/$g 2>/dev/null
 
141
        done
 
142
}
 
143
 
 
144
get_parallel()
 
145
{
 
146
        [ -n "${VE_PARALLEL}" -a "${VE_PARALLEL}" != "0" ] && return
 
147
        VE_PARALLEL=`awk '
 
148
BEGIN { num=0; }
 
149
$1 == "processor" { num++; }
 
150
END { print num * 4; }' /proc/cpuinfo`
 
151
}
 
152
 
 
153
get_veinfo()
 
154
{
 
155
        if [ -f /proc/vz/veinfo ]; then
 
156
                VEINFO=/proc/vz/veinfo
 
157
        elif [ ! -f $VESTAT ]; then
 
158
                return 1
 
159
        fi
 
160
        return 0
 
161
}
 
162
 
 
163
is_running()
 
164
{
 
165
        get_veinfo || return 1
 
166
        [ -f $SUBSYS_VZ ] || return 1
 
167
}
 
168
 
 
169
# Add /vz to PRUNEPATHS in /etc/updatedb.conf so updatedb won't:
 
170
# 1 clog its database with lots of file entries
 
171
# 2 interfere with vzctl umount
 
172
fix_updatedb() {
 
173
        local file="/etc/updatedb.conf"
 
174
        local var="PRUNEPATHS"
 
175
        local add
 
176
 
 
177
        test -r $file || return
 
178
        add=$(printf "$VE_ROOT\n$VE_PRIVATE" | \
 
179
                sed -e 'N;s/^\(.*\).*\n\1.*$/\1/' -e 's@/[^/]*$@@')
 
180
        test "$add" = "/" && return
 
181
        test -d "$add" || return
 
182
        grep -qw "^${var}" $file || return
 
183
        grep -qE "^${var}.* ${add}[\" ]" $file && return
 
184
        __echo "Adding ${add} to ${var} in ${file}:"
 
185
        sed -i.rpmsave \
 
186
                "s@\(^${var}[^\"]*\"[^\"]*\)\(\".*\)\$@\1 ${add}\2@" $file
 
187
        print_result
 
188
}
 
189
 
 
190
status()
 
191
{
 
192
        check_vzkernel
 
193
 
 
194
        if is_running; then
 
195
                echo "OpenVZ is running..."
 
196
                return 0
 
197
        else
 
198
                echo "OpenVZ is stopped."
 
199
                return 3
 
200
        fi
 
201
}
 
202
 
 
203
start_net()
 
204
{
 
205
        local mod
 
206
 
 
207
        # load all kernel modules needed for containers networking
 
208
        for mod in ${NET_MODULES}; do
 
209
                modprobe ${mod} 2>/dev/null
 
210
        done
 
211
 
 
212
        if ip addr list | grep -q "venet0:.*UP" 2>/dev/null; then
 
213
                return 0
 
214
        fi
 
215
 
 
216
        get_veinfo
 
217
        if [ -z "$VEINFO" ]; then
 
218
                return 0
 
219
        fi
 
220
        __echo "Bringing up interface $VZDEV: "
 
221
        ip link set $VZDEV up
 
222
        print_result
 
223
        ip addr add 0.0.0.0/0 dev $VZDEV
 
224
        if [ "${IPV6}" = "yes" ]; then
 
225
                ip -6 addr add fe80::1/128 dev $VZDEV
 
226
        fi
 
227
        sysctl -q -w net.ipv4.conf.$VZDEV.send_redirects=0
 
228
        if [ "$(sysctl -n -e net.ipv4.ip_forward)" != "1" ]; then
 
229
                print_warning "IP forwarding is not enabled"
 
230
        fi
 
231
}
 
232
 
 
233
stop_net()
 
234
{
 
235
        local mod
 
236
 
 
237
        if ip addr list | grep -q "venet0:.*UP" 2>/dev/null; then
 
238
                __echo "Bringing down interface $VZDEV: "
 
239
                ip link set $VZDEV down
 
240
                print_result
 
241
        fi
 
242
        for mod in ${NET_MODULES}; do
 
243
                /sbin/modprobe -r ${mod} > /dev/null 2>&1
 
244
        done
 
245
}
 
246
 
 
247
setup_ve0()
 
248
{
 
249
        mount_cgroups
 
250
 
 
251
        if test -z "${VE0CPUUNITS}"; then
 
252
                echo "Warning: VE0CPUUNITS is not set in ${VZCONF}; using value of 1000"
 
253
                VE0CPUUNITS=1000
 
254
        fi
 
255
        msg=`${VZCTL} set 0 --cpuunits ${VE0CPUUNITS} 2>&1`
 
256
        if [ $? -ne 0 ]; then
 
257
                print_failure "vzctl set 0 --cpuunits ${VE0CPUUNITS} failed: $msg"
 
258
        fi
 
259
 
 
260
        if ! test -f "${CONFIG_DIR}/0.conf"; then
 
261
                return
 
262
        fi
 
263
        if ! grep -q '^ONBOOT=yes\|^ONBOOT=\"yes\"' ${CONFIG_DIR}/0.conf;
 
264
        then
 
265
                return
 
266
        fi
 
267
        __echo "Configure node UB resources: "
 
268
        msg=`$VZCTL set 0 --reset_ub 2>&1`
 
269
        print_result "$msg"
 
270
}
 
271
 
 
272
start_ves()
 
273
{
 
274
        local veid
 
275
        local velist
 
276
        local msg
 
277
        local need_restart
 
278
        local iter=0
 
279
        local header
 
280
        local pid pids
 
281
 
 
282
        need_restart=""
 
283
        # CTs that were running before a reboot
 
284
        velist=$(ls $VZREBOOTDIR)
 
285
        rm -f $VZREBOOTDIR/*
 
286
        # ... and not have ONBOOT=no
 
287
        test -n "$velist" && velist=$(vzlist -aH -octid,onboot $velist |
 
288
                        awk '$2 != "no" {print $1}')
 
289
        # ... plus ones with ONBOOT=yes
 
290
        velist=$(echo "$velist"; vzlist -aH -octid,onboot |
 
291
                        awk '$2 == "yes" {print $1}')
 
292
        # Then sort by bootorder
 
293
        test -n "$velist" && velist=$(vzlist -aH -octid -s-bootorder $velist)
 
294
        sysctl -q -w net.ipv4.route.src_check=0
 
295
        get_parallel
 
296
        for veid in $velist; do
 
297
                [ "${veid}" = "0" ] && continue
 
298
                if [ "x${VZFASTBOOT}" = "xyes" -a "x${DISK_QUOTA}" = "xyes" ];
 
299
                then
 
300
                        $VZQUOTA stat ${veid} >/dev/null 2>&1
 
301
                        if [ $? -eq 6 ]; then
 
302
                                if $VZQUOTA show ${veid} 2>&1 | grep "vzquota : (warning) Quota is running" >/dev/null 2>&1; then
 
303
                                        $VZQUOTA on ${veid} --nocheck >/dev/null 2>&1
 
304
                                        need_restart="${need_restart} ${veid}"
 
305
                                fi
 
306
                        fi
 
307
                fi
 
308
                if [ -z "${header}" ]; then
 
309
                        __echo "Starting CT:"
 
310
                        header=1
 
311
                fi
 
312
                __echo " ${veid}"
 
313
 
 
314
                rm -f $VZREBOOTDIR/$veid
 
315
                $VZCTL start ${veid} >/dev/null 2>&1 &
 
316
                pid=$!
 
317
                eval VE_${pid}=${veid}
 
318
                pids="$pids $pid"
 
319
                let iter++
 
320
                if [ ${iter} -ge ${VE_PARALLEL} ]; then
 
321
                        echo
 
322
                        for pid in ${pids}; do
 
323
                                veid=`eval echo \\$VE_${pid}`
 
324
                                unset VE_${pid}
 
325
                                __echo "Container ${veid} start: "
 
326
                                wait ${pid}
 
327
                                print_result
 
328
                        done
 
329
                        pids=
 
330
                        iter=0
 
331
                        header=
 
332
                fi
 
333
        done
 
334
 
 
335
        [ -n "${pids}" ] && echo
 
336
        for pid in ${pids}; do
 
337
                veid=`eval echo \\$VE_${pid}`
 
338
                unset VE_${pid}
 
339
                __echo "Container ${veid} start: "
 
340
                wait ${pid}
 
341
                print_result
 
342
        done
 
343
 
 
344
        for veid in ${need_restart}; do
 
345
                __echo "Stopping CT ${veid}: "
 
346
                $VZCTL stop ${veid} 2>&1 >/dev/null 2>&1
 
347
                print_result "$msg"
 
348
                __echo "Starting CT ${veid}: "
 
349
                msg=`$VZCTL start ${veid} 2>&1`
 
350
                print_result "$msg"
 
351
        done
 
352
}
 
353
 
 
354
stop_ves()
 
355
{
 
356
        local veid velist i iter pid pids msg stage stages ret
 
357
 
 
358
        if ! get_veinfo; then
 
359
                return
 
360
        fi
 
361
 
 
362
        # Pre-stop stage
 
363
        rm -f $VZREBOOTDIR/*
 
364
        velist=$(vzlist -1 2>/dev/null)
 
365
        for veid in $velist; do
 
366
                # Equalize cpuunits for all CTs
 
367
                $VZCTL set $veid --cpuunits 2000 >/dev/null 2>&1
 
368
                # Save to vzreboot list
 
369
                touch $VZREBOOTDIR/$veid
 
370
        done
 
371
 
 
372
        get_parallel
 
373
        stages="stop"
 
374
        if [ -z "${VE_STOP_MODE}" -o "$VE_STOP_MODE" = "suspend" ]; then
 
375
                stages="suspend stop"
 
376
        fi
 
377
        for stage in $stages; do
 
378
                case $stage in
 
379
                        suspend)
 
380
                                msg='Suspending CT'
 
381
                                ;;
 
382
                        stop)
 
383
                                msg='Shutting down CT'
 
384
                                ;;
 
385
                esac
 
386
                for i in 0 1 2; do
 
387
                        iter=0
 
388
                        pids=
 
389
                        header=
 
390
                        velist=$(vzlist -H -o ctid -sbootorder 2>/dev/null)
 
391
                        for veid in $velist; do
 
392
                                if [ "$stage" = "stop" ]; then
 
393
                                        # Unset limits for CT to stop fast
 
394
                                        $VZCTL set $veid --cpulimit 0 --iolimit 0 --iopslimit 0 >/dev/null 2>&1
 
395
                                fi
 
396
                                if [ -z "${header}" ]; then
 
397
                                        __echo "$msg:"
 
398
                                        header=1
 
399
                                fi
 
400
                                __echo " ${veid}"
 
401
                                $VZCTL --skiplock $stage $veid >/dev/null 2>&1 &
 
402
                                pid=$!
 
403
                                eval VE_${pid}=${veid}
 
404
                                pids="$pids $pid"
 
405
                                iter=$(($iter+1))
 
406
                                if [ ${iter} -ge ${VE_PARALLEL} ]; then
 
407
                                        echo
 
408
                                        for pid in ${pids}; do
 
409
                                                veid=`eval echo \\$VE_${pid}`
 
410
                                                unset VE_${pid}
 
411
                                                __echo "Container ${veid} $stage: "
 
412
                                                wait ${pid}
 
413
                                                print_result
 
414
                                        done
 
415
                                        pids=
 
416
                                        iter=0
 
417
                                        header=
 
418
                                fi
 
419
                        done
 
420
                        [ -n "${pids}" ] && echo
 
421
                        for pid in $pids; do
 
422
                                veid=`eval echo \\$VE_${pid}`
 
423
                                unset VE_${pid}
 
424
                                __echo "Container ${veid} $stage: "
 
425
                                wait $pid
 
426
                                print_result
 
427
                        done
 
428
                done
 
429
        done
 
430
}
 
431
 
 
432
umount_ves()
 
433
{
 
434
        local iter=0
 
435
        local fail=1
 
436
        local m mounts msg quota
 
437
 
 
438
        # umount all simfs mounts
 
439
        while test $iter -lt 5 -a $fail -ne 0; do
 
440
                fail=0
 
441
                mounts=`awk '{if ($3=="simfs") print $2}' /proc/mounts`
 
442
                for m in $mounts; do
 
443
                        __echo "Unmounting CT area "
 
444
                        echo -n $m
 
445
                        msg=`umount $m 2>&1`
 
446
                        if [ $? -eq 0 ]; then
 
447
                                print_success
 
448
                        else
 
449
                                print_failure "$msg"
 
450
                                fail=$((fail+1))
 
451
                                fuser -k -m ${m} > /dev/null 2>&1
 
452
                        fi
 
453
                done
 
454
                iter=$(($iter+1))
 
455
        done
 
456
        # turn quota off
 
457
        quota=`awk -F: '/^[0-9]+:/{print $1}' /proc/vz/vzquota 2>/dev/null`
 
458
        for m in ${quota}; do
 
459
                __echo "Turn quota off for CT "
 
460
                echo -n $m
 
461
                msg=`vzquota off ${m} 2>&1`
 
462
                print_result "$msg"
 
463
        done
 
464
}
 
465
 
 
466
lockfile()
 
467
{
 
468
        local TEMPFILE="${1}.$$"
 
469
        local LOCKFILE="${1}"
 
470
 
 
471
        trap -- "rm -f ${LOCKFILE} ${TEMPFILE}" EXIT
 
472
 
 
473
        echo $$ > ${TEMPFILE} 2> /dev/null || {
 
474
                echo "Can't write to ${TEMPFILE}"
 
475
        }
 
476
        ln ${TEMPFILE} ${LOCKFILE} >/dev/null 2>&1 && {
 
477
                rm -f ${TEMPFILE};
 
478
                return 0;
 
479
        }
 
480
        kill -0 `cat $LOCKFILE` >/dev/null 2>&1 && {
 
481
                trap -- - EXIT
 
482
                return 1;
 
483
        }
 
484
        ln ${TEMPFILE} ${LOCKFILE} >/dev/null 2>&1 && {
 
485
                rm -f ${TEMPFILE};
 
486
                return 0;
 
487
        }
 
488
        rm -f ${LOCKFILE}
 
489
        echo $$ > ${LOCKFILE}
 
490
        return 0
 
491
}
 
492
 
 
493
start()
 
494
{
 
495
        local veid
 
496
        local velist
 
497
        local msg
 
498
        local mod
 
499
 
 
500
        check_vzkernel
 
501
        check_kernel_config
 
502
 
 
503
        if ! lockfile $LOCKFILE; then
 
504
                __echo "OpenVZ is locked"
 
505
                print_failure
 
506
                return 1
 
507
        fi
 
508
        if [ -f ${SUBSYS_VZ} ]; then
 
509
                __echo "OpenVZ already running"
 
510
                print_failure
 
511
                return 1
 
512
        fi
 
513
 
 
514
        # One-time sysctl.conf setup
 
515
        if test -z "$SKIP_SYSCTL_SETUP"; then
 
516
                /usr/lib/vzctl/vzctl/scripts/vz-postinstall sysctl
 
517
                echo "SKIP_SYSCTL_SETUP=yes" >> ${VZCONF}
 
518
        fi
 
519
 
 
520
        __echo "Starting OpenVZ: "
 
521
        load_modules "${IPT_MODULES}"
 
522
        for mod in $PRELOAD_MODULES; do
 
523
                /sbin/modprobe -r $mod >/dev/null 2>&1
 
524
                /sbin/modprobe $mod >/dev/null 2>&1
 
525
        done
 
526
        for mod in $MODULES; do
 
527
                /sbin/modprobe $mod >/dev/null 2>&1
 
528
                RETVAL=$?
 
529
                if [ $RETVAL -ne 0 ]; then
 
530
                        print_failure "failed to load module ${mod}"
 
531
                        return $RETVAL
 
532
                fi
 
533
        done
 
534
        load_modules "${MODULES_OTHER} ${VZFS_MODULES} ${PLOOP_MODULES}"
 
535
        print_success "loading OpenVZ modules"
 
536
 
 
537
        if [ ! -e /dev/vzctl ]; then
 
538
                # On most modern distros udev will create a device for you,
 
539
                # while on the old distros /dev/vzctl comes with vzctl rpm.
 
540
                # So the below mknod call is probably not needed at all.
 
541
                /bin/mknod -m 600 /dev/vzctl c 126 0 > /dev/null 2>&1
 
542
                RETVAL=$?
 
543
                if [ $RETVAL -ne 0 ]; then
 
544
                        print_failure "creating /dev/vzctl"
 
545
                        return $RETVAL
 
546
                fi
 
547
        fi
 
548
 
 
549
        if [ -f /proc/vz/oom_score_adj ]; then
 
550
                __echo "Applying OOM adjustments: "
 
551
                cat /etc/vz/oom-groups.conf > /proc/vz/oom_score_adj
 
552
                print_result
 
553
        fi
 
554
 
 
555
        start_net
 
556
        setup_ve0
 
557
        fix_updatedb
 
558
        start_ves
 
559
 
 
560
        # Try to run vzstats to report new kernel
 
561
        vzstats >/dev/null 2>&1
 
562
 
 
563
        rm -f $LOCKFILE
 
564
        touch $SUBSYS_VZ
 
565
}
 
566
 
 
567
stop()
 
568
{
 
569
        local mod
 
570
 
 
571
        # Avoid stop action inside a CT, check we are in CT0
 
572
        if test -r /proc/user_beancounters; then
 
573
                if ! egrep -q '^[[:space:]]*0:[[:space:]]' \
 
574
                        /proc/user_beancounters; then
 
575
                        print_failure "Looks like we are inside a container!"
 
576
                        RETVAL=1
 
577
                        return 1
 
578
                fi
 
579
        fi
 
580
 
 
581
        if ! lockfile $LOCKFILE; then
 
582
                __echo "OpenVZ is locked"
 
583
                print_failure
 
584
                RETVAL=1
 
585
                return 1
 
586
        fi
 
587
 
 
588
        stop_ves
 
589
        umount_ves
 
590
        umount_cgroups
 
591
        stop_net
 
592
        __echo "Stopping OpenVZ: "
 
593
        for mod in ${MODULES_OTHER} ${MODULES} ${PRELOAD_MODULES} \
 
594
                        ${IPT_MODULES} ${VZFS_MODULES} ${PLOOP_MODULES}; do
 
595
                /sbin/modprobe -r ${mod} > /dev/null 2>&1
 
596
        done
 
597
        rm -f $LOCKFILE
 
598
        rm -f $SUBSYS_VZ
 
599
        print_success
 
600
}
 
601
 
 
602
load_modules()
 
603
{
 
604
        local modules="$1"
 
605
        local mod
 
606
 
 
607
        for mod in ${modules}; do
 
608
                if /sbin/lsmod | grep -qw ${mod}; then
 
609
                        continue
 
610
                fi
 
611
                /sbin/modprobe ${mod} >/dev/null 2>&1
 
612
        done
 
613
}
 
614
 
 
615
# See how we were called.
 
616
case "$1" in
 
617
  start)
 
618
        start
 
619
        ;;
 
620
  stop)
 
621
        stop
 
622
        ;;
 
623
  restart|force-reload)
 
624
        stop
 
625
        start
 
626
        ;;
 
627
  status)
 
628
        status
 
629
        RETVAL=$?
 
630
        ;;
 
631
  *)
 
632
        echo "Usage: $0 {start|stop|status|restart|force-reload}"
 
633
        exit 1
 
634
esac
 
635
 
 
636
exit $RETVAL