include/linux/vserver/limit.h

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