src/planetlab.c

   1 /* Copyright 2005 Princeton University
   2
   3 Redistribution and use in source and binary forms, with or without
   4 modification, are permitted provided that the following conditions
   5 are met:
   6
   7     * Redistributions of source code must retain the above copyright
   8       notice, this list of conditions and the following disclaimer.
   9
  10     * Redistributions in binary form must reproduce the above
  11       copyright notice, this list of conditions and the following
  12       disclaimer in the documentation and/or other materials provided
  13       with the distribution.
  14
  15     * Neither the name of the copyright holder nor the names of its
  16       contributors may be used to endorse or promote products derived
  17       from this software without specific prior written permission.
  18
  19 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL PRINCETON
  23 UNIVERSITY OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  24 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  25 BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  26 OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  27 AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
  29 WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30 POSSIBILITY OF SUCH DAMAGE.
  31
  32 */
  33
  34 #ifdef HAVE_CONFIG_H
  35 #  include <config.h>
  36 #endif
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <errno.h>
  41 #include <stdint.h>
  42 #include <stdarg.h>
  43 #include <unistd.h>
  44 #include <ctype.h>
  45 #include <sys/resource.h>
  46 #include <fcntl.h>
  47
  48 #include "vserver.h"
  49 #include "planetlab.h"
  50
  51 #ifndef VC_NXC_RAW_SOCKET
  52 #  define VC_NXC_RAW_SOCKET     0x00000200ull
  53 #endif
  54 #ifndef VC_NXC_RAW_SEND
  55 #  define VC_NXC_RAW_SEND       0x00000400ull
  56 #endif
  57 #ifndef VC_NXF_LBACK_ALLOW
  58 #  define VC_NXF_LBACK_ALLOW    0x00000400ull
  59 #endif
  60
  61 static int
  62 create_context(xid_t ctx, uint64_t bcaps)
  63 {
  64   struct vc_ctx_caps   vc_caps;
  65   struct vc_net_flags  vc_nf;
  66   struct vc_net_caps   vc_ncaps;
  67   uint32_t unshare_mask;
  68
  69   /* Create network context */
  70   if (vc_net_create(ctx) == VC_NOCTX) {
  71     if (errno == EEXIST)
  72       goto tag;
  73     return -1;
  74   }
  75
  76   /* Make the network context persistent */
  77   vc_nf.mask = vc_nf.flagword = VC_NXF_PERSISTENT | VC_NXF_LBACK_ALLOW;
  78   if (vc_set_nflags(ctx, &vc_nf))
  79     return -1;
  80
  81   /* Give it raw sockets capabilities */
  82   vc_ncaps.ncaps = vc_ncaps.cmask = VC_NXC_RAW_ICMP | VC_NXC_RAW_SOCKET;
  83   if (vc_set_ncaps(ctx, &vc_ncaps))
  84     return -1;
  85
  86 tag:
  87   /* Create tag context */
  88   if (vc_tag_create(ctx) == VC_NOCTX)
  89     return -1;
  90
  91 process:
  92
  93   /*
  94    * Create context info - this sets the STATE_SETUP and STATE_INIT flags.
  95    */
  96   if (vc_ctx_create(ctx, 0) == VC_NOCTX)
  97     return -1;
  98
  99   /* Unshare the net namespace if the slice if requested in the local slice configuration */
 100   unshare_mask = get_space_flag(ctx);
 101   if (unshare_mask != 0) {
 102       sys_unshare(unshare_mask);
 103       vc_set_namespace(ctx, unshare_mask | vc_get_space_mask());
 104   }
 105
 106   /* Set capabilities - these don't take effect until SETUP flag is unset */
 107   vc_caps.bcaps = bcaps;
 108   vc_caps.bmask = ~0ULL;  /* currently unused */
 109   vc_caps.ccaps = 0;      /* don't want any of these */
 110   vc_caps.cmask = ~0ULL;
 111   if (vc_set_ccaps(ctx, &vc_caps))
 112     return -1;
 113
 114   if (pl_setsched(ctx, 0, 1) < 0) {
 115     PERROR("pl_setsched(%u)", ctx);
 116     exit(1);
 117   }
 118
 119   return 0;
 120 }
 121
 122 int
 123 pl_setup_done(xid_t ctx)
 124 {
 125   struct vc_ctx_flags  vc_flags;
 126
 127   /* unset SETUP flag - this allows other processes to migrate */
 128   /* set the PERSISTENT flag - so the context doesn't vanish */
 129   /* Don't clear the STATE_INIT flag, as that would make us the init task. */
 130   vc_flags.mask = VC_VXF_STATE_SETUP|VC_VXF_PERSISTENT;
 131   vc_flags.flagword = VC_VXF_PERSISTENT;
 132   if (vc_set_cflags(ctx, &vc_flags))
 133     return -1;
 134
 135   return 0;
 136 }
 137
 138 #define RETRY_LIMIT  10
 139
 140 int
 141 pl_chcontext(xid_t ctx, uint64_t bcaps, const struct sliver_resources *slr)
 142 {
 143   int  retry_count = 0;
 144   int  net_migrated = 0;
 145
 146   if (pl_set_ulimits(slr) != 0)
 147     return -1;
 148
 149   for (;;)
 150     {
 151       struct vc_ctx_flags  vc_flags;
 152
 153       if (vc_get_cflags(ctx, &vc_flags))
 154         {
 155           if (errno != ESRCH)
 156             return -1;
 157
 158           /* context doesn't exist - create it */
 159           if (create_context(ctx, bcaps))
 160             {
 161               if (errno == EEXIST)
 162                 /* another process beat us in a race */
 163                 goto migrate;
 164               if (errno == EBUSY)
 165                 /* another process is creating - poll the SETUP flag */
 166                 continue;
 167               return -1;
 168             }
 169
 170           /* created context and migrated to it i.e., we're done */
 171           return 1;
 172         }
 173
 174       /* check the SETUP flag */
 175       if (vc_flags.flagword & VC_VXF_STATE_SETUP)
 176         {
 177           /* context is still being setup - wait a while then retry */
 178           if (retry_count++ >= RETRY_LIMIT)
 179             {
 180               errno = EBUSY;
 181               return -1;
 182             }
 183           sleep(1);
 184           continue;
 185         }
 186
 187       /* context has been setup */
 188     migrate:
 189       if (net_migrated || !vc_net_migrate(ctx))
 190         {
 191           if (!vc_tag_migrate(ctx) && !vc_ctx_migrate(ctx, 0))
 192             break;  /* done */
 193           net_migrated = 1;
 194         }
 195
 196       /* context disappeared - retry */
 197     }
 198
 199   return 0;
 200 }
 201
 202 /* it's okay for a syscall to fail because the context doesn't exist */
 203 #define VC_SYSCALL(x)                           \
 204 do                                              \
 205 {                                               \
 206   if (x)                                        \
 207     return errno == ESRCH ? 0 : -1;             \
 208 }                                               \
 209 while (0)
 210
 211 int
 212 pl_setsched(xid_t ctx, uint32_t cpu_min, uint32_t cpu_share)
 213 {
 214   struct vc_set_sched  vc_sched;
 215   struct vc_ctx_flags  vc_flags;
 216
 217   vc_sched.set_mask = (VC_VXSM_FILL_RATE | VC_VXSM_INTERVAL | VC_VXSM_TOKENS |
 218                        VC_VXSM_TOKENS_MIN | VC_VXSM_TOKENS_MAX | VC_VXSM_MSEC |
 219                        VC_VXSM_FILL_RATE2 | VC_VXSM_INTERVAL2 | VC_VXSM_FORCE);
 220   vc_sched.fill_rate = cpu_min; /* percent reserved */
 221   vc_sched.interval = 100;
 222   vc_sched.fill_rate2 = cpu_share; /* best-effort fair share of unreserved */
 223   vc_sched.interval2 = 1000;  /* milliseconds */
 224   vc_sched.tokens = 100;     /* initial allocation of tokens */
 225   vc_sched.tokens_min = 50;  /* need this many tokens to run */
 226   vc_sched.tokens_max = 100;  /* max accumulated number of tokens */
 227
 228   if (cpu_share) {
 229     if (cpu_share == (uint32_t)VC_LIM_KEEP)
 230       vc_sched.set_mask &= ~(VC_VXSM_FILL_RATE|VC_VXSM_FILL_RATE2);
 231     else
 232       vc_sched.set_mask |= VC_VXSM_IDLE_TIME;
 233   }
 234
 235   VC_SYSCALL(vc_set_sched(ctx, &vc_sched));
 236
 237   vc_flags.mask = VC_VXF_SCHED_FLAGS;
 238   vc_flags.flagword = VC_VXF_SCHED_HARD;
 239   VC_SYSCALL(vc_set_cflags(ctx, &vc_flags));
 240
 241   return 0;
 242 }
 243
 244 enum {
 245   TYPE_LONG = 1,
 246   TYPE_PERS = 2,
 247 };
 248
 249 struct pl_resources {
 250         char *name;
 251         unsigned type;
 252   union {
 253     unsigned long long *limit;
 254     unsigned long int *personality;
 255   };
 256 };
 257
 258 #define WHITESPACE(buffer,index,len)     \
 259   while(isspace((int)buffer[index])) \
 260         if (index < len) index++; else goto out;
 261
 262 #define VSERVERCONF "/etc/vservers/"
 263
 264 void
 265 pl_get_limits(const char *context, struct sliver_resources *slr)
 266 {
 267   FILE *fb;
 268   int cwd;
 269   size_t len = strlen(VSERVERCONF) + strlen(context) + NULLBYTE_SIZE;
 270   char *conf = (char *)malloc(len + strlen("rlimits/openfd.hard"));
 271   struct pl_resources *r;
 272   struct pl_resources sliver_list[] = {
 273     {"sched/fill-rate2", TYPE_LONG, &slr->vs_cpu},
 274
 275     {"rlimits/nproc.hard", TYPE_LONG, &slr->vs_nproc.hard},
 276     {"rlimits/nproc.soft", TYPE_LONG, &slr->vs_nproc.soft},
 277     {"rlimits/nproc.min", TYPE_LONG, &slr->vs_nproc.min},
 278
 279     {"rlimits/rss.hard", TYPE_LONG, &slr->vs_rss.hard},
 280     {"rlimits/rss.soft", TYPE_LONG, &slr->vs_rss.soft},
 281     {"rlimits/rss.min", TYPE_LONG, &slr->vs_rss.min},
 282
 283     {"rlimits/as.hard", TYPE_LONG, &slr->vs_as.hard},
 284     {"rlimits/as.soft", TYPE_LONG, &slr->vs_as.soft},
 285     {"rlimits/as.min", TYPE_LONG, &slr->vs_as.min},
 286
 287     {"rlimits/openfd.hard", TYPE_LONG, &slr->vs_openfd.hard},
 288     {"rlimits/openfd.soft", TYPE_LONG, &slr->vs_openfd.soft},
 289     {"rlimits/openfd.min", TYPE_LONG, &slr->vs_openfd.min},
 290
 291     {"personality", TYPE_PERS, &slr->personality},
 292
 293     {0,0}
 294   };
 295
 296   sprintf(conf, "%s%s", VSERVERCONF, context);
 297
 298   slr->vs_rss.hard = VC_LIM_KEEP;
 299   slr->vs_rss.soft = VC_LIM_KEEP;
 300   slr->vs_rss.min = VC_LIM_KEEP;
 301
 302   slr->vs_as.hard = VC_LIM_KEEP;
 303   slr->vs_as.soft = VC_LIM_KEEP;
 304   slr->vs_as.min = VC_LIM_KEEP;
 305
 306   slr->vs_nproc.hard = VC_LIM_KEEP;
 307   slr->vs_nproc.soft = VC_LIM_KEEP;
 308   slr->vs_nproc.min = VC_LIM_KEEP;
 309
 310   slr->vs_openfd.hard = VC_LIM_KEEP;
 311   slr->vs_openfd.soft = VC_LIM_KEEP;
 312   slr->vs_openfd.min = VC_LIM_KEEP;
 313
 314   slr->personality = 0;
 315
 316   cwd = open(".", O_RDONLY);
 317   if (cwd == -1) {
 318     perror("cannot get a handle on .");
 319     goto out;
 320   }
 321   if (chdir(conf) == -1) {
 322     fprintf(stderr, "cannot chdir to ");
 323     perror(conf);
 324     goto out_fd;
 325   }
 326
 327   for (r = &sliver_list[0]; r->name; r++) {
 328     char buf[1000];
 329     fb = fopen(r->name, "r");
 330     if (fb == NULL)
 331       continue;
 332     if (fgets(buf, sizeof(buf), fb) != NULL) {
 333       len=strlen(buf);
 334       /* remove trailing newline */
 335       if (buf[len-1] == '\n') {
 336         buf[len-1]='\0';
 337         len --;
 338       }
 339       if ( (r->type == TYPE_LONG) && isdigit(*buf)) {
 340         *r->limit = atoi(buf);
 341       } else if ( (r->type == TYPE_PERS) && isalpha(*buf)) {
 342         unsigned long int res;
 343         res = vc_str2personalitytype(buf,len);
 344         if (res != VC_BAD_PERSONALITY) {
 345           *r->personality = res;
 346         }
 347       }
 348     }
 349
 350     fclose(fb);
 351   }
 352
 353   fchdir(cwd);
 354 out_fd:
 355   close(cwd);
 356 out:
 357   free(conf);
 358 }
 359
 360 int
 361 adjust_lim(const struct vc_rlimit *vcr, struct rlimit *lim)
 362 {
 363   int adjusted = 0;
 364   if (vcr->min != VC_LIM_KEEP) {
 365     if (vcr->min > lim->rlim_cur) {
 366       lim->rlim_cur = vcr->min;
 367       adjusted = 1;
 368     }
 369     if (vcr->min > lim->rlim_max) {
 370       lim->rlim_max = vcr->min;
 371       adjusted = 1;
 372     }
 373   }
 374
 375   if (vcr->soft != VC_LIM_KEEP) {
 376     switch (vcr->min != VC_LIM_KEEP) {
 377     case 1:
 378       if (vcr->soft < vcr->min)
 379         break;
 380     case 0:
 381         lim->rlim_cur = vcr->soft;
 382         adjusted = 1;
 383     }
 384   }
 385
 386   if (vcr->hard != VC_LIM_KEEP) {
 387     switch (vcr->min != VC_LIM_KEEP) {
 388     case 1:
 389       if (vcr->hard < vcr->min)
 390         break;
 391     case 0:
 392         lim->rlim_max = vcr->hard;
 393         adjusted = 1;
 394     }
 395   }
 396   return adjusted;
 397 }
 398
 399 static inline void
 400 set_one_ulimit(int resource, const struct vc_rlimit *limit)
 401 {
 402   struct rlimit lim;
 403   getrlimit(resource, &lim);
 404   adjust_lim(limit, &lim);
 405   setrlimit(resource, &lim);
 406 }
 407
 408 static inline int
 409 set_personality(unsigned long int personality_arg)
 410 {
 411   if (personality_arg == 0)
 412     return 0;
 413   if (personality(personality_arg) < 0) {
 414     return -1;
 415   }
 416   return 0;
 417 }
 418
 419 int
 420 pl_set_ulimits(const struct sliver_resources *slr)
 421 {
 422   if (!slr)
 423     return 0;
 424
 425   set_one_ulimit(RLIMIT_RSS, &slr->vs_rss);
 426   set_one_ulimit(RLIMIT_AS, &slr->vs_as);
 427   set_one_ulimit(RLIMIT_NPROC, &slr->vs_nproc);
 428   set_one_ulimit(RLIMIT_NOFILE, &slr->vs_openfd);
 429   return set_personality(slr->personality);
 430 }