use $(LIBENSCVECTOR) instead of libensc_vector.a
[util-vserver.git] / util-vserver / kernel / limit.h
index 00b1a6d..d9e1eea 100644 (file)
@@ -1,3 +1,5 @@
+/* _VX_LIMIT_H defined below */
+
 #if    defined(__KERNEL__) && defined(_VX_INFO_DEF_)
 
 #include <asm/atomic.h>
@@ -5,36 +7,87 @@
 
 /* context sub struct */
 
+#define NUM_LIMITS     20
+
+#define VLIMIT_NSOCK   16
+
+
+extern const char *vlimit_name[NUM_LIMITS];
+
 struct _vx_limit {
        atomic_t ticks;
 
-       unsigned long rlim[RLIM_NLIMITS];       /* Per context limit */
-       atomic_t res[RLIM_NLIMITS];             /* Current value */
+       unsigned long rlim[NUM_LIMITS];         /* Context limit */
+       unsigned long rmax[NUM_LIMITS];         /* Context maximum */
+       atomic_t rcur[NUM_LIMITS];              /* Current value */
+       atomic_t lhit[NUM_LIMITS];              /* Limit hits */
 };
 
 static inline void vx_info_init_limit(struct _vx_limit *limit)
 {
        int lim;
 
-       for (lim=0; lim<RLIM_NLIMITS; lim++)
+       for (lim=0; lim<NUM_LIMITS; lim++) {
                limit->rlim[lim] = RLIM_INFINITY;
+               limit->rmax[lim] = 0;
+               atomic_set(&limit->rcur[lim], 0);
+               atomic_set(&limit->lhit[lim], 0);
+       }
+}
+
+static inline void vx_info_exit_limit(struct _vx_limit *limit)
+{
+#ifdef CONFIG_VSERVER_DEBUG
+       unsigned long value;
+       unsigned int lim;
+
+       for (lim=0; lim<NUM_LIMITS; lim++) {
+               value = atomic_read(&limit->rcur[lim]);
+               if (value)
+                       printk("!!! limit: %p[%s,%d] = %ld on exit.\n",
+                               limit, vlimit_name[lim], lim, value);
+       }
+#endif
+}
+
+static inline void vx_limit_fixup(struct _vx_limit *limit)
+{
+       unsigned long value;
+       unsigned int lim;
+
+       for (lim=0; lim<NUM_LIMITS; lim++) {
+               value = atomic_read(&limit->rcur[lim]);
+               if (value > limit->rmax[lim])
+                       limit->rmax[lim] = value;
+               if (limit->rmax[lim] > limit->rlim[lim])
+                       limit->rmax[lim] = limit->rlim[lim];
+       }
 }
 
+#define VX_LIMIT_FMT   ":\t%10d\t%10ld\t%10ld\t%6d\n"
+
+#define VX_LIMIT_ARG(r)                                \
+               ,atomic_read(&limit->rcur[r])   \
+               ,limit->rmax[r]                 \
+               ,limit->rlim[r]                 \
+               ,atomic_read(&limit->lhit[r])
+
 static inline int vx_info_proc_limit(struct _vx_limit *limit, char *buffer)
 {
+       vx_limit_fixup(limit);
        return sprintf(buffer,
-               "PROC:\t%8d/%ld\n"
-               "VM:\t%8d/%ld\n"
-               "VML:\t%8d/%ld\n"               
-               "RSS:\t%8d/%ld\n"
-               ,atomic_read(&limit->res[RLIMIT_NPROC])
-               ,limit->rlim[RLIMIT_NPROC]
-               ,atomic_read(&limit->res[RLIMIT_AS])
-               ,limit->rlim[RLIMIT_AS]
-               ,atomic_read(&limit->res[RLIMIT_MEMLOCK])
-               ,limit->rlim[RLIMIT_MEMLOCK]
-               ,atomic_read(&limit->res[RLIMIT_RSS])
-               ,limit->rlim[RLIMIT_RSS]
+               "PROC"  VX_LIMIT_FMT
+               "VM"    VX_LIMIT_FMT
+               "VML"   VX_LIMIT_FMT
+               "RSS"   VX_LIMIT_FMT
+               "FILES" VX_LIMIT_FMT
+               "SOCK"  VX_LIMIT_FMT
+               VX_LIMIT_ARG(RLIMIT_NPROC)
+               VX_LIMIT_ARG(RLIMIT_AS)
+               VX_LIMIT_ARG(RLIMIT_MEMLOCK)
+               VX_LIMIT_ARG(RLIMIT_RSS)
+               VX_LIMIT_ARG(RLIMIT_NOFILE)
+               VX_LIMIT_ARG(VLIMIT_NSOCK)
                );
 }
 
@@ -44,20 +97,22 @@ static inline int vx_info_proc_limit(struct _vx_limit *limit, char *buffer)
 
 #include "switch.h"
 
+#define VXD_RLIMIT(r,l)                (VXD_CBIT(limit, (l)) && ((r) == (l)))
+
 /*  rlimit vserver commands */
 
 #define VCMD_get_rlimit                VC_CMD(RLIMIT, 1, 0)
 #define VCMD_set_rlimit                VC_CMD(RLIMIT, 2, 0)
 #define VCMD_get_rlimit_mask   VC_CMD(RLIMIT, 3, 0)
 
-struct  vcmd_ctx_rlimit_v0 {
+struct vcmd_ctx_rlimit_v0 {
        uint32_t id;
        uint64_t minimum;
        uint64_t softlimit;
        uint64_t maximum;
 };
 
-struct  vcmd_ctx_rlimit_mask_v0 {
+struct vcmd_ctx_rlimit_mask_v0 {
        uint32_t minimum;
        uint32_t softlimit;
        uint32_t maximum;
@@ -68,16 +123,22 @@ struct  vcmd_ctx_rlimit_mask_v0 {
 #define CRLIM_KEEP             (~1ULL)
 
 #ifdef __KERNEL__
-extern int vc_get_rlimit(uint32_t, void *);
-extern int vc_set_rlimit(uint32_t, void *);
-extern int vc_get_rlimit_mask(uint32_t, void *);
+
+#include <linux/compiler.h>
+
+extern int vc_get_rlimit(uint32_t, void __user *);
+extern int vc_set_rlimit(uint32_t, void __user *);
+extern int vc_get_rlimit_mask(uint32_t, void __user *);
 
 struct sysinfo;
 
 void vx_vsi_meminfo(struct sysinfo *);
 void vx_vsi_swapinfo(struct sysinfo *);
 
+
 #endif /* __KERNEL__ */
 
 #endif /* _VX_LIMIT_H */
 #endif
+
+