Changeset 129

Show
Ignore:
Timestamp:
03/04/06 11:19:15 (3 years ago)
Author:
bonbons
Message:

Many changes and bug-fixes, now requires vs2.1.1-rc11, libvserver trunk

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • branches/1.0.4/scripts/lib/vps.sh

    r115 r129  
    101101        case ${subcmd} in 
    102102                setup) 
    103                         ${_VNCONTEXT} -C -n ${VX_XID} -f PERSISTANT,INIT_SET 
    104                         ${_VCONTEXT}  -C -x ${VX_XID} -f PERSISTANT,INIT_SET 
     103                        ${_VNCONTEXT} -C -n ${VX_XID} -f PERSISTANT,STATE_SETUP 
     104                        ${_VNFLAGS} -G -m -n ${VX_XID} 
     105                        ${_VCONTEXT}  -C -x ${VX_XID} -f PERSISTANT,STATE_SETUP 
     106                        ${_VFLAGS} -G -m -x ${VX_XID} 
    105107                        ;; 
    106108                 
     
    127129                                ${_VNCONTEXT} -A -n ${VX_XID} -a ${i} 
    128130                        done 
     131                        ${_VNFLAGS} -G -m -n ${VX_XID} 
    129132                        ;; 
    130133                 
     
    144147                new) 
    145148                        ${_VNAMESPACE} -N -x ${VX_XID} 
     149                        ${_VFLAGS} -G -m -x ${VX_XID} 
    146150                        ;; 
    147151                 
     
    149153                        [ -z "$1" ] && util.error "vps.namespace: missing argument <command>" 
    150154                        ${_VNAMESPACE} -E -x ${VX_XID} -- "$@" 
     155                        ${_VFLAGS} -G -m -x ${VX_XID} 
    151156                        ;; 
    152157                 
     
    234239                                ${_VFLAGS} -S -b $(util.array_to_list ${VX_BCAPS[@]}) -x ${VX_XID} 
    235240                        fi 
    236                          
     241                        ${_VFLAGS} -G -m -x ${VX_XID} 
    237242                        if [ ! -z "${VX_CCAPS}" ]; then 
    238243                                ${_VFLAGS} -S -c $(util.array_to_list ${VX_CCAPS[@]}) -x ${VX_XID} 
    239244                        fi 
    240                          
     245                        ${_VFLAGS} -G -m -x ${VX_XID} 
    241246                        if [ ! -z "${VX_FLAGS}" ]; then 
    242                                 ${_VFLAGS} -S -f $(util.array_to_list ${VX_FLAGS[@]}) -x ${VX_XID} 
     247                                ${_VFLAGS} -S -f $(util.array_to_list ${VX_FLAGS[@]}),STATE_SETUP -x ${VX_XID} 
    243248                        fi 
     249                        ${_VFLAGS} -G -m -x ${VX_XID} 
    244250                        ;; 
    245251                 
     
    255261         
    256262        pushd ${VDIR} >/dev/null 
    257          
     263        ${_VFLAGS} -G -m -x ${VX_XID} 
     264        ${_VNFLAGS} -G -m -n ${VX_XID} 
    258265        case ${VX_INIT} in 
    259266                sysvinit|init|plain) 
     
    285292                        ;; 
    286293        esac 
    287          
     294        ${_VFLAGS} -G -m -x ${VX_XID} 
     295        ${_VNFLAGS} -G -m -n ${VX_XID} 
    288296        popd >/dev/null 
    289297} 
     
    393401                popd >/dev/null 
    394402        fi 
    395          
     403        ${_VFLAGS} -G -m -x ${VX_XID} 
    396404        return 0 
    397405} 
     
    412420        ${_VNAMESPACE} -E -x ${VX_XID} -- \ 
    413421        ${_VMOUNT} -U -f ${fstab} -m etc/mtab 
    414          
     422        ${_VFLAGS} -G -m -x ${VX_XID} 
    415423        popd >/dev/null 
    416424} 
  • branches/1.0.4/src/libinternal/Makefile.am

    r78 r129  
    2020           -I$(top_builddir)/src 
    2121 
    22 noinst_HEADERS = printf.h 
     22noinst_HEADERS = printf.h vlist.h syscall.h sys.h 
    2323 
    2424noinst_LIBRARIES = libinternal.a 
    2525 
    26 libinternal_a_SOURCES = printf.c 
     26libinternal_a_SOURCES = printf.c list.c sys_clone.c \ 
     27        bcaps-list.c cflags-list.c nflags-list.c \ 
     28        sched-list.c ccaps-list.c iattr-list.c \ 
     29        rlimit-list.c vhi-list.c mflags-list.c 
     30 
  • branches/1.0.4/src/libvconfig/main.c

    r78 r129  
    2626#include <stdlib.h> 
    2727#include <stdio.h> 
    28  
    29 #include <linux/vserver/cvirt_cmd.h> 
    3028 
    3129#include "printf.h" 
  • branches/1.0.4/src/tools/lockfile.c

    r115 r129  
    4747 
    4848struct options { 
     49        GLOBAL_OPTS; 
    4950        char *lockfile; 
    5051        char *syncpipe; 
     
    5455/* init program data */ 
    5556struct options opts = { 
     57        GLOBAL_OPTS_INIT, 
    5658        .lockfile = NULL, 
    5759        .syncpipe = NULL, 
     
    6567               "\n" 
    6668               "Available options:\n" 
     69               GLOBAL_HELP 
    6770               "    -l <file>     Lock file\n" 
    6871               "    -s <fifo>     Sync pipe\n" 
     
    9497        int c; 
    9598         
     99        DEBUGF("%s: starting ...\n", NAME); 
     100 
    96101        /* parse command line */ 
    97102        while (1) { 
  • branches/1.0.4/src/tools/tools.h

    r78 r129  
    1919 ***************************************************************************/ 
    2020 
    21 #define GLOBAL_CMDS "hV" 
     21#define GLOBAL_CMDS "hVv" 
     22 
     23#define GLOBAL_OPTS bool verbose 
     24 
     25#define GLOBAL_OPTS_INIT .verbose = false 
    2226 
    2327#define GLOBAL_CMDS_GETOPT \ 
     
    2933        CMD_VERSION(NAME, DESCR); \ 
    3034        break; \ 
     35\ 
     36case 'v': \ 
     37        opts.verbose = true; \ 
     38        break; \ 
     39 
     40#define GLOBAL_HELP "    -h            Display this help message\n" \ 
     41        "    -V            Display vserver-utils version\n" \ 
     42        "    -v            Enable verbose output\n" 
    3143 
    3244#define DEFAULT_GETOPT \ 
     
    5971#define EXIT_OPTS    3 
    6072 
     73#define VPRINTF(opts, fmt, ...) if ((opts)->verbose) vu_printf(fmt , __VA_ARGS__ ) 
     74#ifdef DEBUG 
     75#define DEBUGF(fmt, ...) vu_printf("DEBUG: " fmt , __VA_ARGS__ ) 
     76#else 
     77#define DEBUGF(fmt, ...) 
     78#endif 
     79 
    6180#define EXIT(MSG,RC) { \ 
    6281        vu_printf(MSG"; try '%s -h' for more information\n", argv[0]); \ 
  • branches/1.0.4/src/tools/vattr.c

    r115 r129  
    3737#include <vserver.h> 
    3838 
    39 #include <linux/vserver/inode.h> 
    40  
    4139#include "printf.h" 
    4240#include "tools.h" 
     41#include "vlist.h" 
    4342 
    4443#define NAME  "vattr" 
     
    4746#define SHORT_OPTS "SGacdf:lrx:" 
    4847 
    49 struct commands { 
    50         bool set; 
    51         bool get; 
    52 }; 
     48typedef enum { VATTR_NONE, VATTR_GET, VATTR_SET } command_t; 
    5349 
    5450struct options { 
     51        GLOBAL_OPTS; 
     52        command_t cmd; 
    5553        bool all; 
    5654        bool cross; 
     
    6462 
    6563/* init program data */ 
    66 struct commands cmds = { 
    67         .get = false, 
    68         .set = false, 
    69 }; 
    70  
    71 /* init program data */ 
    7264struct options opts = { 
     65        GLOBAL_OPTS_INIT, 
     66        .cmd     = VATTR_NONE, 
    7367        .all     = false, 
    7468        .cross   = false, 
     
    9387               "\n" 
    9488               "Available options:\n" 
     89               GLOBAL_HELP 
    9590               "    -a            Process entries starting with a dot\n" 
    9691               "    -c            Do not cross filesystems\n" 
     
    125120        iattr.filename = file; 
    126121         
    127         if (cmds.set) { 
     122        if (opts.cmd == VATTR_SET) { 
    128123                const char clmod = '~'; // clear flag modifier 
    129124                 
     
    157152                 
    158153                if (opts.xid != 0) { 
    159                         iattr.flags |= IATTR_XID
    160                         iattr.mask  |= IATTR_XID
     154                        iattr.flags |= IATTR_TAG
     155                        iattr.mask  |= IATTR_TAG
    161156                } 
    162157                 
     
    211206                } 
    212207                 
    213                 if (iattr.mask & IATTR_XID
     208                if (iattr.mask & IATTR_TAG
    214209                        vu_snprintf(ptr, 7, " %5d", iattr.xid); 
    215210                else 
     
    365360        } 
    366361 
    367         if (opts.dirent || !S_ISDIR(st.st_mode || cmds.set)) { 
     362        if (opts.dirent || !S_ISDIR(st.st_mode || opts.cmd == VATTR_SET)) { 
    368363                /* First operate on the file/folder itself if either: 
    369364                 * - It's not a directory 
     
    382377        // If we need to recurse, do it 
    383378        if (S_ISDIR(st.st_mode) && 
    384            ((cmds.set && opts.recurse) || (!cmds.set && !opts.dirent))) { 
     379           ((opts.cmd == VATTR_SET && opts.recurse) || (!opts.cmd == VATTR_GET && !opts.dirent))) { 
    385380                rc = walk_tree(path, 0); 
    386381        } 
     
    398393        const char delim = ','; // list delimiter 
    399394         
     395        DEBUGF("%s: starting ...\n", NAME); 
     396 
    400397        /* parse command line */ 
    401398        while (1) { 
     
    407404                         
    408405                        case 'S': 
    409                                 cmds.set = true; 
     406                                if (opts.cmd != VATTR_NONE) 
     407                                        cmd_help(); 
     408                                else 
     409                                        opts.cmd = VATTR_SET; 
    410410                                break; 
    411411                         
    412412                        case 'G': 
    413                                 cmds.get = true; 
     413                                if (opts.cmd != VATTR_NONE) 
     414                                        cmd_help(); 
     415                                else 
     416                                        opts.cmd = VATTR_GET; 
    414417                                break; 
    415418                         
  • branches/1.0.4/src/tools/vconfig.c

    r115 r129  
    3939#define SHORT_OPTS "GLSk:n:" 
    4040 
    41 struct commands { 
    42         bool get; 
    43         bool list; 
    44         bool set; 
    45 }; 
     41typedef enum { VCFG_NONE, VCFG_LIST, VCFG_GET, VCFG_SET } command_t; 
    4642 
    4743struct options { 
     44        GLOBAL_OPTS; 
     45        command_t cmd; 
    4846        char *name; 
    4947        char *key; 
     
    6159               "\n" 
    6260               "Available options:\n" 
     61               GLOBAL_HELP 
    6362               "    -n <name>     VServer name\n" 
    6463               "    -k <key>      Configuration key\n" 
     
    7069int main(int argc, char *argv[]) 
    7170{ 
    72         /* init program data */ 
    73         struct commands cmds = { 
    74                 .get  = false, 
    75                 .list = false, 
    76                 .set  = false, 
    77         }; 
    78          
    7971        struct options opts = { 
     72                GLOBAL_OPTS_INIT, 
     73                .cmd  = VCFG_NONE, 
    8074                .name = NULL, 
    8175                .key  = NULL, 
     
    8377         
    8478        int c; 
     79         
     80        DEBUGF("%s: starting ...\n", NAME); 
    8581         
    8682        /* parse command line */ 
     
    9389                         
    9490                        case 'G': 
    95                                 cmds.get = true; 
     91                                if (opts.cmd != VCFG_NONE) 
     92                                        cmd_help(); 
     93                                else 
     94                                        opts.cmd = VCFG_GET; 
    9695                                break; 
    9796                         
    9897                        case 'L': 
    99                                 cmds.list = true; 
     98                                if (opts.cmd != VCFG_NONE) 
     99                                        cmd_help(); 
     100                                else 
     101                                        opts.cmd = VCFG_LIST; 
    100102                                break; 
    101103                         
    102104                        case 'S': 
    103                                 cmds.set = true; 
     105                                if (opts.cmd != VCFG_NONE) 
     106                                        cmd_help(); 
     107                                else 
     108                                        opts.cmd = VCFG_SET; 
    104109                                break; 
    105110                         
     
    116121        } 
    117122         
    118         if (cmds.get) { 
    119                 if (opts.name == NULL) 
    120                         EXIT("<name> missing", EXIT_USAGE); 
     123        switch (opts.cmd) { 
     124                case VCFG_GET: { 
     125                        if (opts.name == NULL) 
     126                                EXIT("<name> missing", EXIT_USAGE); 
    121127                 
    122                 if (opts.key == NULL) 
    123                         EXIT("<key> missing", EXIT_USAGE); 
     128                       if (opts.key == NULL) 
     129                               EXIT("<key> missing", EXIT_USAGE); 
    124130                 
    125                 if (vconfig_isbool(opts.key) == 0) { 
    126                         int buf = vconfig_get_bool(opts.name, opts.key); 
     131                       if (vconfig_isbool(opts.key) == 0) { 
     132                               int buf = vconfig_get_bool(opts.name, opts.key); 
    127133                         
    128                         if (buf != -1) { 
    129                                 if (buf == 1) 
    130                                  vu_printf("true\n"); 
    131                                 else 
    132                                  vu_printf("false\n"); 
     134                                if (buf != -1) { 
     135                                        if (buf == 1) 
     136                                                vu_printf("true\n"); 
     137                                        else 
     138                                                vu_printf("false\n"); 
     139                                } 
    133140                        } 
     141                 
     142                        if (vconfig_isint(opts.key) == 0) { 
     143                                int buf = vconfig_get_int(opts.name, opts.key); 
     144                                if (buf != -1) 
     145                                        vu_printf("%d\n", buf); 
     146                        } 
     147                 
     148                        if (vconfig_isstr(opts.key) == 0) { 
     149                                char *buf = vconfig_get_str(opts.name, opts.key); 
     150                         
     151                                if (buf != NULL) { 
     152                                        vu_printf("%s\n", buf); 
     153                                        free(buf); 
     154                                } 
     155                        } 
     156                 
     157                        if (vconfig_islist(opts.key) == 0) { 
     158                                char *buf = vconfig_get_list(opts.name, opts.key); 
     159                         
     160                                if (buf != NULL) { 
     161                                        vu_printf("%s\n", buf); 
     162                                        free(buf); 
     163                                } 
     164                        } 
     165                        break; 
    134166                } 
    135                  
    136                 if (vconfig_isint(opts.key) == 0) { 
    137                         int buf = vconfig_get_int(opts.name, opts.key); 
    138                         if (buf != -1) 
    139                          vu_printf("%d\n", buf); 
     167                case VCFG_LIST: { 
     168                        vconfig_print_nodes(); 
     169                        break; 
    140170                } 
    141                  
    142                 if (vconfig_isstr(opts.key) == 0) { 
    143                         char *buf = vconfig_get_str(opts.name, opts.key); 
    144                          
    145                         if (buf != NULL) { 
    146                          vu_printf("%s\n", buf); 
    147                                 free(buf); 
    148                         } 
     171                case VCFG_SET: { 
     172                        vu_printf("SET command not implemented\n"); 
     173                        return -1; 
     174                        break; 
    149175                } 
    150                  
    151                 if (vconfig_islist(opts.key) == 0) { 
    152                         char *buf = vconfig_get_list(opts.name, opts.key); 
    153                          
    154                         if (buf != NULL) { 
    155                          vu_printf("%s\n", buf); 
    156                                 free(buf); 
    157                         } 
    158                 } 
    159         } 
    160          
    161         if (cmds.list) { 
    162                 vconfig_print_nodes(); 
    163         } 
    164          
    165         if (cmds.set) { 
    166                 return -1; 
     176                default: 
     177                        cmd_help(); 
    167178        } 
    168179         
  • branches/1.0.4/src/tools/vcontext.c

    r78 r129  
    3232#include "printf.h" 
    3333#include "tools.h" 
     34#include "vlist.h" 
    3435 
    3536#define NAME  "vcontext" 
    3637#define DESCR "Context Manager" 
    3738 
    38 #define SHORT_OPTS "CIMx:f:" 
    39  
    40 struct commands { 
    41         bool create; 
    42         bool info; 
    43         bool migrate; 
    44 }; 
     39#define SHORT_OPTS "CIMx:f:c:b:m" 
     40 
     41typedef enum { VCTX_NONE, VCTX_CREATE, VCTX_INFO, VCTX_MIGRATE } command_t; 
    4542 
    4643struct options { 
     44        GLOBAL_OPTS; 
     45        command_t cmd; 
    4746        xid_t xid; 
    4847        list_t *flags; 
     48        list_t *bcaps; 
     49        list_t *ccaps; 
     50        list_t *mflags; 
    4951}; 
    5052 
     
    6062               "\n" 
    6163               "Available options:\n" 
     64               GLOBAL_HELP 
    6265               "    -x <xid>      Context ID\n" 
    6366               "    -f <list>     Set flags described in <list>\n" 
     67               "    -b <list>     Set bcaps described in <list>\n" 
     68               "    -c <list>     Set ccaps described in <list>\n" 
     69/*             "    -m <list>     Set migration flags described in <list>\n" */ 
    6470               "\n" 
    6571               "Flag list format string:\n" 
     
    7480int main(int argc, char *argv[]) 
    7581{ 
    76         /* init program data */ 
    77         struct commands cmds = { 
    78                 .create   = false, 
    79                 .info     = false, 
    80                 .migrate  = false, 
    81         }; 
    82          
    8382        struct options opts = { 
     83                GLOBAL_OPTS_INIT, 
     84                .cmd   = VCTX_NONE, 
    8485                .xid   = (~0U), 
    8586                .flags = 0, 
    8687        }; 
    8788         
    88         /* init syscall data */ 
    89         struct vx_create_flags create_flags = { 
    90                 .flags = 0, 
    91         }; 
    92          
    9389        struct vx_info info; 
    94          
    95         /* init flags list */ 
    96         list_t *cp = cflags_list_init(); 
    9790         
    9891        int c; 
    9992        const char delim = ','; // list delimiter 
    10093        const char clmod = '~'; // clear flag modifier 
     94         
     95        DEBUGF("%s: starting ...\n", NAME); 
    10196         
    10297        /* parse command line */ 
     
    109104                         
    110105                        case 'C': 
    111                                 cmds.create = true; 
     106                                if (opts.cmd != VCTX_NONE) 
     107                                        cmd_help(); 
     108                                else 
     109                                        opts.cmd = VCTX_CREATE; 
    112110                                break; 
    113111                         
    114112                        case 'I': 
    115                                 cmds.info = true; 
     113                                if (opts.cmd != VCTX_NONE) 
     114                                        cmd_help(); 
     115                                else 
     116                                        opts.cmd = VCTX_INFO; 
    116117                                break; 
    117118                         
    118119                        case 'M': 
    119                                 cmds.migrate = true; 
     120                                if (opts.cmd != VCTX_NONE) 
     121                                        cmd_help(); 
     122                                else 
     123                                        opts.cmd = VCTX_MIGRATE; 
    120124                                break; 
    121125                         
     
    128132                                break; 
    129133                         
     134                        case 'c': 
     135                                opts.ccaps = list_parse_list(optarg, delim); 
     136                                break; 
     137                                 
     138                        case 'b': 
     139                                opts.bcaps = list_parse_list(optarg, delim); 
     140                                break; 
     141                                 
     142                        case 'm': 
     143                                opts.mflags = list_parse_list(optarg, delim); 
     144                                break; 
     145                         
    130146                        DEFAULT_GETOPT 
    131147                } 
    132148        } 
    133          
    134         if (cmds.create) { 
    135                 if (opts.flags == 0) 
    136                         goto create; 
     149 
     150        switch (opts.cmd) { 
     151                case VCTX_CREATE: { 
     152                        struct vx_create_flags create_flags = { 
     153                                .flags = VXF_STATE_SETUP, 
     154                        }; 
     155                        if (opts.flags) { 
     156                                /* init flags list */ 
     157                                list_t *cp = cflags_list_init(); 
     158 
     159                                list_link_t link = { 
     160                                        .p = cp, 
     161                                        .d = opts.flags, 
     162                                }; 
     163                                uint64_t fmask = 0; 
     164                                 
     165                                /* validate descending list */ 
     166                                if (list_validate_flag(&link, clmod) == -1) 
     167                                        PEXIT("List validation failed", EXIT_USAGE); 
     168                         
     169                                /* convert given descending list to flags using the pristine copy */ 
     170                                list_list2flags(&link, clmod, &create_flags.flags, &fmask); 
     171                                create_flags.flags |= VXF_STATE_SETUP; 
     172                        } 
     173                         
     174                        /* syscall */ 
     175                        if (vx_create(opts.xid, &create_flags) == -1) 
     176                                PEXIT("Failed to create context", EXIT_COMMAND); 
     177                         
     178                        /* Set as default values those used by util-vserver */ 
     179                        if (opts.ccaps == NULL) opts.ccaps = list_parse_list("SET_UTSNAME,RAW_ICMP", delim); 
     180                        if (opts.bcaps == NULL) opts.bcaps = list_parse_list("CHOWN,DAC_OVERRIDE,DAC_READ_SEARCH," 
     181                                        "FOWNER,FSETID,FS_MASK,KILL,SETGID,SETUID,NET_BIND_SERVICE,SYS_CHROOT," 
     182                                        "SYS_PTRACE,SYS_BOOT,SYS_TTY_CONFIG,LEASE,SYS_ADMIN", delim); 
     183                        if (opts.ccaps || opts.bcaps) { 
     184                                struct vx_caps caps = { 
     185                                        .bcaps = 0, 
     186                                        .ccaps = 0, 
     187                                        .cmask = 0, 
     188                                }; 
     189                                list_t *bp = bcaps_list_init(); 
     190                                list_t *cp = ccaps_list_init(); 
     191                                 
     192                                list_link_t link = { 
     193                                        .p = bp, 
     194                                        .d = opts.bcaps, 
     195                                }; 
     196 
     197                                /* validate descending list */ 
     198                                if (list_validate_flag(&link, clmod) == -1) 
     199                                        PEXIT("List validation failed", EXIT_USAGE); 
     200                                /* convert given descending list to flags using the pristine copy */ 
     201                                list_list2flags(&link, clmod, &caps.bcaps, &caps.cmask); 
     202 
     203                                link.p = cp; 
     204                                link.d = opts.ccaps; 
     205                                /* validate descending list */ 
     206                                if (list_validate_flag(&link, clmod) == -1) 
     207                                        PEXIT("List validation failed", EXIT_USAGE); 
     208                                /* convert given descending list to flags using the pristine copy */ 
     209                                list_list2flags(&link, clmod, &caps.ccaps, &caps.cmask); 
     210 
     211                                /* Finally set the caps */ 
     212                                if (vx_set_caps(opts.xid, &caps) == -1) 
     213                                        PEXIT("Failed to set context capabilities", EXIT_COMMAND); 
     214                        } 
     215                        if (argc > optind) { 
     216                                struct vx_flags flags = { 
     217                                        .flags = 0, 
     218                                        .mask  = VXF_STATE_SETUP, 
     219                                }; 
     220                                if (vx_set_flags(opts.xid, &flags) == -1) 
     221                                        PEXIT("Failed to set context flags", EXIT_COMMAND); 
     222                        } 
     223                        break; 
     224                } 
     225                case VCTX_MIGRATE: { 
     226                        struct vx_migrate_flags migrate_flags = { 
     227                                .flags = 0, 
     228                        }; 
     229 
     230                        if (opts.mflags) { 
     231                                /* init flags list */ 
     232                                list_t *mp = mflags_list_init(); 
     233                                 
     234                                list_link_t link = { 
     235                                        .p = mp, 
     236                                        .d = opts.mflags, 
     237                                }; 
     238                                uint64_t fmask = 0; 
     239                                 
     240                                /* validate descending list */ 
     241                                if (list_validate_flag(&link, clmod) == -1) 
     242                                        PEXIT("List validation failed", EXIT_USAGE); 
     243                                 
     244                                /* convert given descending list to flags using the pristine copy */ 
     245                                list_list2flags(&link, clmod, &migrate_flags.flags, &fmask); 
     246                        } 
     247                        /* syscall */ 
     248                        if (vx_migrate(opts.xid, &migrate_flags) == -1) 
     249                                PEXIT("Failed to migrate to context", EXIT_COMMAND); 
     250                        break; 
     251                } 
     252                case VCTX_INFO: { 
     253                        /* syscall */ 
     254                        if (vx_get_info(opts.xid, &info) == -1) 
     255                                PEXIT("Failed to get context information", EXIT_COMMAND); 
    137256                 
    138                 list_link_t link = { 
    139                         .p = cp, 
    140                         .d = opts.flags, 
    141                 }; 
     257                        vu_printf("Context ID: %d\n", info.xid); 
     258                        vu_printf("Init PID: %d\n", info.initpid); 
    142259                 
    143                 /* validate descending list */ 
    144                 if (list_validate_flag(&link, clmod) == -1) 
    145                         PEXIT("List validation failed", EXIT_USAGE); 
    146                  
    147                 /* vx_create_flags has no mask member 
    148                  * so we create a dumb one */ 
    149                 uint64_t mask = 0; 
    150                  
    151                 /* convert given descending list to flags using the pristine copy */ 
    152                 list_list2flags(&link, clmod, &create_flags.flags, &mask); 
    153                  
    154 create: 
    155                 /* syscall */ 
    156                 if (vx_create(opts.xid, &create_flags) == -1) 
    157                         PEXIT("Failed to create context", EXIT_COMMAND); 
    158                  
    159                 goto load; 
     260                        goto out; 
     261                } 
     262                default: 
     263                        cmd_help(); 
    160264        } 
    161265         
    162         if (cmds.migrate) { 
    163                 /* syscall */ 
    164                 if (vx_migrate(opts.xid) == -1) 
    165                         PEXIT("Failed to migrate to context", EXIT_COMMAND); 
    166                  
    167                 goto load; 
    168         } 
    169          
    170         if (cmds.info) { 
    171                 /* syscall */ 
    172                 if (vx_get_info(opts.xid, &info) == -1) 
    173                         PEXIT("Failed to get context information", EXIT_COMMAND); 
    174                  
    175                 vu_printf("Context ID: %d\n", info.xid); 
    176                 vu_printf("Init PID: %d\n", info.initpid); 
    177                  
    178           &