Changeset 2449

Show
Ignore:
Timestamp:
01/10/07 19:53:07 (2 years ago)
Author:
dhozac
Message:

Add vc_sched_info API.
Make vserver-stat use the various APIs instead of parsing per-process /proc entries.

vc_virt_stat.uptime is a uint64_t.
vc_get_dlimit can handle a NULL limits argument.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/kernel/sched_cmd.h

    r2413 r2449  
    77#define VCMD_set_sched_v2       VC_CMD(SCHED, 1, 2) 
    88#define VCMD_set_sched_v3       VC_CMD(SCHED, 1, 3) 
    9 #define VCMD_set_sched        VC_CMD(SCHED, 1, 4) 
     9#define VCMD_set_sched_v4     VC_CMD(SCHED, 1, 4) 
    1010 
    1111struct  vcmd_set_sched_v2 { 
     
    4040}; 
    4141 
     42#define VCMD_set_sched          VC_CMD(SCHED, 1, 5) 
     43#define VCMD_get_sched          VC_CMD(SCHED, 2, 5) 
     44 
     45struct  vcmd_sched_v5 { 
     46        uint32_t mask; 
     47        int32_t cpu_id; 
     48        int32_t bucket_id; 
     49        int32_t fill_rate[2]; 
     50        int32_t interval[2]; 
     51        int32_t tokens; 
     52        int32_t tokens_min; 
     53        int32_t tokens_max; 
     54        int32_t prio_bias; 
     55}; 
    4256 
    4357#define VXSM_FILL_RATE          0x0001 
     
    5973#define VXSM_BUCKET_ID          0x2000 
    6074 
     75#define VXSM_MSEC               0x4000 
     76 
    6177#define SCHED_KEEP              (-2)    /* only for v2 */ 
    6278 
     79 
     80#define VCMD_sched_info         VC_CMD(SCHED, 3, 0) 
     81 
     82struct  vcmd_sched_info { 
     83        int32_t cpu_id; 
     84        int32_t bucket_id; 
     85        uint64_t user_msec; 
     86        uint64_t sys_msec; 
     87        uint64_t hold_msec; 
     88        uint32_t token_usec; 
     89        int32_t vavavoom; 
     90}; 
     91 
    6392#endif  /* _VX_SCHED_CMD_H */ 
  • trunk/lib/Makefile-files

    r2427 r2449  
    129129                                lib/syscall_ctxmigrate-v21.hc \ 
    130130                                lib/syscall_setmapping.c \ 
    131                                 lib/syscall_setmapping-v21.hc 
     131                                lib/syscall_setmapping-v21.hc \ 
     132                                lib/syscall_schedinfo.c \ 
     133                                lib/syscall_schedinfo-v21.hc 
    132134 
    133135if ENSC_HAVE_C99_COMPILER 
  • trunk/lib/issupported.c

    r2247 r2449  
    4444    case vcFEATURE_SCHED        :  return ver >= 0x00020000;  // todo 
    4545    case vcFEATURE_VNET         :  return ver >= 0x00020001; 
     46    case vcFEATURE_VSTAT        :  return ver >= 0x00020103; 
    4647    default                     :  assert(false);  
    4748  } 
  • trunk/lib/issupportedstring.c

    r2247 r2449  
    3535  DECL(MIGRATE), DECL(NAMESPACE), DECL(SCHED),    DECL(VINFO), 
    3636  DECL(VHI),     DECL(VSHELPER0), DECL(VSHELPER), DECL(VWAIT), 
    37   DECL(VNET) 
     37  DECL(VNET),    DECL(VSTAT), 
    3838}; 
    3939 
  • trunk/lib/vserver.h

    r2441 r2449  
    415415  struct vc_virt_stat { 
    416416      uint_least64_t    offset; 
    417       uint_least32_t  uptime; 
     417      uint_least64_t  uptime; 
    418418      uint_least32_t    nr_threads; 
    419419      uint_least32_t    nr_running; 
     
    721721  int           vc_get_dlimit(char const *filename, xid_t xid, 
    722722                              uint_least32_t flags, 
    723                               struct vc_ctx_dlimit *limits) VC_ATTR_NONNULL((1,4)); 
    724  
    725     /* misc. syscalls */ 
     723                              struct vc_ctx_dlimit *limits) VC_ATTR_NONNULL((1)); 
     724 
     725    /* scheduler related syscalls */ 
    726726  struct vc_set_sched { 
    727727      uint_least32_t    set_mask; 
     
    740740  int           vc_set_sched(xid_t xid, struct vc_set_sched const *) VC_ATTR_NONNULL((2)); 
    741741 
     742  struct vc_sched_info { 
     743      int_least32_t     cpu_id; 
     744      int_least32_t     bucket_id; 
     745      uint_least64_t    user_msec; 
     746      uint_least64_t    sys_msec; 
     747      uint_least64_t    hold_msec; 
     748      uint_least32_t    token_usec; 
     749      int_least32_t     vavavoom; 
     750  }; 
     751 
     752  int           vc_sched_info(xid_t xid, struct vc_sched_info *info) VC_ATTR_NONNULL((2)); 
     753 
     754    /* misc. syscalls */ 
    742755  int           vc_set_mapping(xid_t xid, const char *device, const char *target, uint32_t flags); 
    743756 
     
    871884                 vcFEATURE_SCHED,  vcFEATURE_VINFO,   vcFEATURE_VHI, 
    872885                 vcFEATURE_VSHELPER0, vcFEATURE_VSHELPER, vcFEATURE_VWAIT, 
    873                  vcFEATURE_VNET
     886                 vcFEATURE_VNET, vcFEATURE_VSTAT
    874887    vcFeatureSet; 
    875888 
  • trunk/src/vserver-stat.c

    r2403 r2449  
    4343#include <getopt.h> 
    4444#include <sys/param.h> 
     45#include <sys/resource.h> 
    4546 
    4647#define ENSC_WRAPPERS_DIRENT    1 
     
    5152 
    5253#define PROC_DIR_NAME "/proc" 
     54#define PROC_VIRT_DIR_NAME "/proc/virtual" 
    5355#define CTX_DIR_NAME "/var/run/vservers/" 
    5456#define CTX_NAME_MAX_LEN 50 
     
    224226} 
    225227 
     228static void 
     229registerXidVstat(struct Vector *vec, unsigned long xid_l) 
     230{ 
     231  xid_t                 xid = (xid_t) xid_l; 
     232  struct XidData        *res; 
     233  struct vc_rlimit_stat limit[3]; 
     234  struct vc_virt_stat   vstat; 
     235  struct vc_sched_info  sched; 
     236  int                   cpu; 
     237 
     238  res = Vector_search(vec, &xid, cmpData); 
     239  if (res!=0) { 
     240    WRITE_MSG(2, "Duplicate xid found?!\n"); 
     241    return; 
     242  } 
     243  if (vc_virt_stat(xid, &vstat) == -1) { 
     244    perror("vc_virt_stat()"); 
     245    return; 
     246  } 
     247  if (vc_rlimit_stat(xid, RLIMIT_NPROC, &limit[0]) == -1) { 
     248    perror("vc_rlimit_stat(RLIMIT_NRPOC)"); 
     249    return; 
     250  } 
     251  if (vc_rlimit_stat(xid, RLIMIT_AS, &limit[1]) == -1) { 
     252    perror("vc_rlimit_stat(RLIMIT_AS)"); 
     253    return; 
     254  } 
     255  if (vc_rlimit_stat(xid, RLIMIT_RSS, &limit[2]) == -1) { 
     256    perror("vc_rlimit_stat(RLIMIT_RSS)"); 
     257    return; 
     258  } 
     259 
     260  res                   = Vector_insert(vec, &xid, cmpData); 
     261  res->xid              = xid; 
     262 
     263  res->process_count    = limit[0].value; 
     264  res->VmSize_total     = limit[1].value * pagesize; 
     265  res->VmRSS_total      = limit[2].value; 
     266  res->start_time_oldest= getUptime() - vstat.uptime/1000000; 
     267 
     268  res->utime_total      = 0; 
     269  res->stime_total      = 0; 
     270  // XXX: arbitrary CPU limit. 
     271  for (cpu = 0; cpu < 1024; cpu++) { 
     272    sched.cpu_id = cpu; 
     273    sched.bucket_id = 0; 
     274    if (vc_sched_info(xid, &sched) == -1) 
     275      break; 
     276 
     277    res->utime_total    += sched.user_msec; 
     278    res->stime_total    += sched.sys_msec; 
     279  } 
     280} 
     281 
    226282static inline uint64_t 
    227283toMsec(uint64_t v) 
     
    573629  Vector_init(&xid_data, sizeof(struct XidData)); 
    574630 
    575   Echdir(PROC_DIR_NAME); 
    576   proc_dir = Eopendir("."); 
    577   while ((dir_entry = readdir(proc_dir)) != NULL) 
    578   { 
     631  if (vc_isSupported(vcFEATURE_VSTAT)) { 
     632    unsigned long xid; 
     633    Echdir(PROC_VIRT_DIR_NAME); 
     634    proc_dir = Eopendir("."); 
     635    while ((dir_entry = readdir(proc_dir)) != NULL) { 
     636      if (!isNumberUnsigned(dir_entry->d_name, &xid, false)) 
     637        continue; 
     638 
     639      registerXidVstat(&xid_data, xid); 
     640    } 
     641    closedir(proc_dir); 
     642  } 
     643  else { 
     644    Echdir(PROC_DIR_NAME); 
     645    proc_dir = Eopendir("."); 
     646    while ((dir_entry = readdir(proc_dir)) != NULL) 
     647    { 
    579648      // select only process file 
    580     if (!isdigit(*dir_entry->d_name)) 
    581       continue; 
    582  
    583     if (atoi(dir_entry->d_name) != my_pid) { 
    584       struct process_info *     info = get_process_info(dir_entry->d_name); 
    585       if (info) 
    586         registerXid(&xid_data, info); 
     649      if (!isdigit(*dir_entry->d_name)) 
     650        continue; 
     651 
     652      if (atoi(dir_entry->d_name) != my_pid) { 
     653        struct process_info *   info = get_process_info(dir_entry->d_name); 
     654        if (info) 
     655          registerXid(&xid_data, info); 
     656      } 
    587657    } 
    588   } 
    589   closedir(proc_dir); 
     658    closedir(proc_dir); 
     659  } 
    590660 
    591661  Vector_foreach(&xid_data, fillName, 0);