include/linux/vserver/limit.h

   1 /* _VX_LIMIT_H defined below */
   2
   3 #if     defined(__KERNEL__) && defined(_VX_INFO_DEF_)
   4
   5 #include <asm/atomic.h>
   6 #include <asm/resource.h>
   7
   8 /* context sub struct */
   9
  10 #define NUM_LIMITS      20
  11
  12 #define VLIMIT_NSOCK    16
  13
  14 extern const char *vlimit_name[NUM_LIMITS];
  15
  16 struct _vx_limit {
  17         atomic_t ticks;
  18
  19         unsigned long rlim[NUM_LIMITS];         /* Context limit */
  20         unsigned long rmax[NUM_LIMITS];         /* Context maximum */
  21         atomic_t rcur[NUM_LIMITS];              /* Current value */
  22         atomic_t lhit[NUM_LIMITS];              /* Limit hits */
  23 };
  24
  25 static inline void vx_info_init_limit(struct _vx_limit *limit)
  26 {
  27         int lim;
  28
  29         for (lim=0; lim<NUM_LIMITS; lim++) {
  30                 limit->rlim[lim] = RLIM_INFINITY;
  31                 limit->rmax[lim] = 0;
  32                 atomic_set(&limit->rcur[lim], 0);
  33                 atomic_set(&limit->lhit[lim], 0);
  34         }
  35 }
  36
  37 static inline void vx_info_exit_limit(struct _vx_limit *limit)
  38 {
  39 #ifdef  CONFIG_VSERVER_DEBUG
  40         unsigned long value;
  41         unsigned int lim;
  42
  43         for (lim=0; lim<NUM_LIMITS; lim++) {
  44                 value = atomic_read(&limit->rcur[lim]);
  45                 if (value)
  46                         printk("!!! limit: %p[%s,%d] = %ld on exit.\n",
  47                                 limit, vlimit_name[lim], lim, value);
  48         }
  49 #endif
  50 }
  51
  52 static inline void vx_limit_fixup(struct _vx_limit *limit)
  53 {
  54         unsigned long value;
  55         unsigned int lim;
  56
  57         for (lim=0; lim<NUM_LIMITS; lim++) {
  58                 value = atomic_read(&limit->rcur[lim]);
  59                 if (value > limit->rmax[lim])
  60                         limit->rmax[lim] = value;
  61                 if (limit->rmax[lim] > limit->rlim[lim])
  62                         limit->rmax[lim] = limit->rlim[lim];
  63         }
  64 }
  65
  66 #define VX_LIMIT_FMT    ":\t%10d\t%10ld\t%10ld\t%6d\n"
  67
  68 #define VX_LIMIT_ARG(r)                         \
  69                 ,atomic_read(&limit->rcur[r])   \
  70                 ,limit->rmax[r]                 \
  71                 ,limit->rlim[r]                 \
  72                 ,atomic_read(&limit->lhit[r])
  73
  74 static inline int vx_info_proc_limit(struct _vx_limit *limit, char *buffer)
  75 {
  76         vx_limit_fixup(limit);
  77         return sprintf(buffer,
  78                 "PROC"  VX_LIMIT_FMT
  79                 "VM"    VX_LIMIT_FMT
  80                 "VML"   VX_LIMIT_FMT
  81                 "RSS"   VX_LIMIT_FMT
  82                 "FILES" VX_LIMIT_FMT
  83                 "SOCK"  VX_LIMIT_FMT
  84                 VX_LIMIT_ARG(RLIMIT_NPROC)
  85                 VX_LIMIT_ARG(RLIMIT_AS)
  86                 VX_LIMIT_ARG(RLIMIT_MEMLOCK)
  87                 VX_LIMIT_ARG(RLIMIT_RSS)
  88                 VX_LIMIT_ARG(RLIMIT_NOFILE)
  89                 VX_LIMIT_ARG(VLIMIT_NSOCK)
  90                 );
  91 }
  92
  93 #else   /* _VX_INFO_DEF_ */
  94 #ifndef _VX_LIMIT_H
  95 #define _VX_LIMIT_H
  96
  97 #include "switch.h"
  98
  99 #define VXD_RLIMIT(r,l)         (VXD_CBIT(limit, (l)) && ((r) == (l)))
 100
 101 /*  rlimit vserver commands */
 102
 103 #define VCMD_get_rlimit         VC_CMD(RLIMIT, 1, 0)
 104 #define VCMD_set_rlimit         VC_CMD(RLIMIT, 2, 0)
 105 #define VCMD_get_rlimit_mask    VC_CMD(RLIMIT, 3, 0)
 106
 107 struct  vcmd_ctx_rlimit_v0 {
 108         uint32_t id;
 109         uint64_t minimum;
 110         uint64_t softlimit;
 111         uint64_t maximum;
 112 };
 113
 114 struct  vcmd_ctx_rlimit_mask_v0 {
 115         uint32_t minimum;
 116         uint32_t softlimit;
 117         uint32_t maximum;
 118 };
 119
 120 #define CRLIM_UNSET             (0ULL)
 121 #define CRLIM_INFINITY          (~0ULL)
 122 #define CRLIM_KEEP              (~1ULL)
 123
 124 #ifdef  __KERNEL__
 125
 126 #include <linux/compiler.h>
 127
 128 extern int vc_get_rlimit(uint32_t, void __user *);
 129 extern int vc_set_rlimit(uint32_t, void __user *);
 130 extern int vc_get_rlimit_mask(uint32_t, void __user *);
 131
 132 struct sysinfo;
 133
 134 void vx_vsi_meminfo(struct sysinfo *);
 135 void vx_vsi_swapinfo(struct sysinfo *);
 136
 137
 138 #endif  /* __KERNEL__ */
 139
 140 #endif  /* _VX_LIMIT_H */
 141 #endif
 142
 143