Changeset 36539


Ignore:
Timestamp:
2013-05-03T17:16:49+02:00 (5 years ago)
Author:
luka
Message:

Config.in: update options for cgroups and namespaces

Signed-off-by: Luka Perkov <luka@…>

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/Config.in

    r36538 r36539  
    305305        # 
    306306 
    307         config KERNEL_FREEZER 
    308                 bool 
    309                 default y if KERNEL_CGROUP_FREEZER 
    310                 depends on KERNEL_CGROUPS 
    311  
    312         config KERNEL_CGROUP_FREEZER 
    313                 bool 
    314                 depends on KERNEL_CGROUPS 
    315  
    316         config KERNEL_CGROUP_DEVICE 
    317                 bool 
    318                 depends on KERNEL_CGROUPS 
    319  
    320         config KERNEL_CPUSETS 
    321                 bool 
    322                 default y if KERNEL_CGROUP_CPUACCT 
    323                 depends on KERNEL_CGROUPS 
    324  
    325         config KERNEL_PROC_PID_CPUSET 
    326                 bool 
    327                 default y if KERNEL_CGROUP_CPUACCT 
    328                 depends on KERNEL_CGROUPS 
    329  
    330         config KERNEL_CGROUP_CPUACCT 
    331                 bool 
    332                 depends on KERNEL_CGROUPS 
    333  
    334         config KERNEL_RESOURCE_COUNTERS 
    335                 bool 
    336                 default y if KERNEL_CGROUP_MEM_RES_CTLR 
    337                 depends on KERNEL_CGROUPS 
    338  
    339         config KERNEL_CGROUP_MEM_RES_CTLR 
    340                 bool 
    341                 depends on KERNEL_CGROUPS 
    342  
    343         config KERNEL_CGROUP_MEM_RES_CTLR_SWAP 
    344                 bool 
    345                 depends on KERNEL_CGROUPS 
    346  
    347         config KERNEL_CGROUP_MEM_RES_CTLR_SWAP_ENABLED 
    348                 bool 
    349                 depends on KERNEL_CGROUPS 
    350  
    351         config KERNEL_CGROUP_MEM_RES_CTLR_KMEM 
    352                 bool 
    353                 depends on KERNEL_CGROUPS 
    354  
    355         config KERNEL_CGROUP_PERF 
    356                 bool 
    357                 depends on KERNEL_CGROUPS 
    358  
    359         config KERNEL_CFS_BANDWIDTH 
    360                 bool 
    361                 default y if KERNEL_FAIR_GROUP_SCHED 
    362                 depends on KERNEL_CGROUP_SCHED 
    363  
    364         config KERNEL_FAIR_GROUP_SCHED 
    365                 bool 
    366                 default y if KERNEL_CGROUP_SCHED 
    367                 depends on KERNEL_CGROUP_SCHED 
    368  
    369         config KERNEL_RT_GROUP_SCHED 
    370                 bool 
    371                 default y if KERNEL_CGROUP_SCHED 
    372                 depends on KERNEL_CGROUP_SCHED 
    373  
    374         config KERNEL_CGROUP_SCHED 
    375                 bool 
    376                 depends on KERNEL_CGROUPS 
    377  
    378         config KERNEL_NET_CLS_CGROUP 
    379                 bool 
    380                 depends on KERNEL_CGROUPS 
    381  
    382         config KERNEL_NETPRIO_CGROUP 
    383                 bool 
    384                 depends on KERNEL_CGROUPS 
    385  
    386         config KERNEL_BLK_CGROUP 
    387                 bool 
    388                 depends on KERNEL_CGROUPS 
    389  
    390         config KERNEL_DEBUG_BLK_CGROUP 
    391                 bool 
    392                 default n if KERNEL_CGROUPS 
    393                 depends on KERNEL_CGROUPS 
    394  
    395307        config KERNEL_CGROUPS 
    396308                bool "Enable kernel cgroups" 
    397309                default n 
    398                 select KERNEL_CGROUP_FREEZER 
    399                 select KERNEL_CGROUP_DEVICE 
    400                 select KERNEL_CGROUP_CPUACCT 
    401                 select KERNEL_CGROUP_MEM_RES_CTLR 
    402                 select KERNEL_CGROUP_MEM_RES_CTLR_SWAP 
    403                 select KERNEL_CGROUP_MEM_RES_CTLR_SWAP_ENABLED 
    404                 select KERNEL_CGROUP_MEM_RES_CTLR_KMEM 
    405                 select KERNEL_CGROUP_PERF 
    406                 select KERNEL_CGROUP_SCHED 
    407                 select KERNEL_NET_CLS_CGROUP 
    408                 select KERNEL_NETPRIO_CGROUP 
    409                 select KERNEL_BLK_CGROUP 
     310 
     311        if KERNEL_CGROUPS 
     312 
     313                config KERNEL_CGROUP_DEBUG 
     314                        bool "Example debug cgroup subsystem" 
     315                        default n 
     316                        help 
     317                          This option enables a simple cgroup subsystem that 
     318                          exports useful debugging information about the cgroups 
     319                          framework. 
     320 
     321                config KERNEL_FREEZER 
     322                        bool 
     323                        default y if KERNEL_CGROUP_FREEZER 
     324 
     325                config KERNEL_CGROUP_FREEZER 
     326                        bool "Freezer cgroup subsystem" 
     327                        default n 
     328                        help 
     329                          Provides a way to freeze and unfreeze all tasks in a 
     330                          cgroup. 
     331 
     332                config KERNEL_CGROUP_DEVICE 
     333                        bool "Device controller for cgroups" 
     334                        default y 
     335                        help 
     336                          Provides a cgroup implementing whitelists for devices which 
     337                          a process in the cgroup can mknod or open. 
     338 
     339                config KERNEL_CPUSETS 
     340                        bool "Cpuset support" 
     341                        default n 
     342                        help 
     343                          This option will let you create and manage CPUSETs which 
     344                          allow dynamically partitioning a system into sets of CPUs and 
     345                          Memory Nodes and assigning tasks to run only within those sets. 
     346                          This is primarily useful on large SMP or NUMA systems. 
     347 
     348                config KERNEL_PROC_PID_CPUSET 
     349                        bool "Include legacy /proc/<pid>/cpuset file" 
     350                        default n 
     351                        depends on KERNEL_CPUSETS 
     352 
     353                config KERNEL_CGROUP_CPUACCT 
     354                        bool "Simple CPU accounting cgroup subsystem" 
     355                        default n 
     356                        help 
     357                          Provides a simple Resource Controller for monitoring the 
     358                          total CPU consumed by the tasks in a cgroup. 
     359 
     360                config KERNEL_RESOURCE_COUNTERS 
     361                        bool "Resource counters" 
     362                        default n 
     363                        help 
     364                          This option enables controller independent resource accounting 
     365                          infrastructure that works with cgroups. 
     366 
     367                config KERNEL_MM_OWNER 
     368                        bool 
     369                        default y if KERNEL_MEMCG 
     370 
     371                config KERNEL_MEMCG 
     372                        bool "Memory Resource Controller for Control Groups" 
     373                        default n 
     374                        depends on KERNEL_RESOURCE_COUNTERS 
     375                        help 
     376                          Provides a memory resource controller that manages both anonymous 
     377                          memory and page cache. (See Documentation/cgroups/memory.txt) 
     378 
     379                          Note that setting this option increases fixed memory overhead 
     380                          associated with each page of memory in the system. By this, 
     381                          20(40)bytes/PAGE_SIZE on 32(64)bit system will be occupied by memory 
     382                          usage tracking struct at boot. Total amount of this is printed out 
     383                          at boot. 
     384 
     385                          Only enable when you're ok with these trade offs and really 
     386                          sure you need the memory resource controller. Even when you enable 
     387                          this, you can set "cgroup_disable=memory" at your boot option to 
     388                          disable memory resource controller and you can avoid overheads. 
     389                          (and lose benefits of memory resource controller) 
     390 
     391                          This config option also selects MM_OWNER config option, which 
     392                          could in turn add some fork/exit overhead. 
     393 
     394                config KERNEL_MEMCG_SWAP 
     395                        bool "Memory Resource Controller Swap Extension" 
     396                        default n 
     397                        depends on KERNEL_MEMCG 
     398                        help 
     399                          Add swap management feature to memory resource controller. When you 
     400                          enable this, you can limit mem+swap usage per cgroup. In other words, 
     401                          when you disable this, memory resource controller has no cares to 
     402                          usage of swap...a process can exhaust all of the swap. This extension 
     403                          is useful when you want to avoid exhaustion swap but this itself 
     404                          adds more overheads and consumes memory for remembering information. 
     405                          Especially if you use 32bit system or small memory system, please 
     406                          be careful about enabling this. When memory resource controller 
     407                          is disabled by boot option, this will be automatically disabled and 
     408                          there will be no overhead from this. Even when you set this config=y, 
     409                          if boot option "swapaccount=0" is set, swap will not be accounted. 
     410                          Now, memory usage of swap_cgroup is 2 bytes per entry. If swap page 
     411                          size is 4096bytes, 512k per 1Gbytes of swap. 
     412 
     413                config KERNEL_MEMCG_SWAP_ENABLED 
     414                        bool "Memory Resource Controller Swap Extension enabled by default" 
     415                        default n 
     416                        depends on KERNEL_MEMCG_SWAP 
     417                        help 
     418                          Memory Resource Controller Swap Extension comes with its price in 
     419                          a bigger memory consumption. General purpose distribution kernels 
     420                          which want to enable the feature but keep it disabled by default 
     421                          and let the user enable it by swapaccount boot command line 
     422                          parameter should have this option unselected. 
     423                          For those who want to have the feature enabled by default should 
     424                          select this option (if, for some reason, they need to disable it 
     425                          then swapaccount=0 does the trick). 
     426 
     427 
     428                config KERNEL_MEMCG_KMEM 
     429                        bool "Memory Resource Controller Kernel Memory accounting (EXPERIMENTAL)" 
     430                        default n 
     431                        depends on KERNEL_MEMCG 
     432                        help 
     433                          The Kernel Memory extension for Memory Resource Controller can limit 
     434                          the amount of memory used by kernel objects in the system. Those are 
     435                          fundamentally different from the entities handled by the standard 
     436                          Memory Controller, which are page-based, and can be swapped. Users of 
     437                          the kmem extension can use it to guarantee that no group of processes 
     438                          will ever exhaust kernel resources alone. 
     439 
     440                config KERNEL_PERF_EVENTS 
     441                        bool 
     442                        default y if KERNEL_CGROUP_PERF 
     443 
     444                config KERNEL_CGROUP_PERF 
     445                        bool "Enable perf_event per-cpu per-container group (cgroup) monitoring" 
     446                        default n 
     447                        help 
     448                          This option extends the per-cpu mode to restrict monitoring to 
     449                          threads which belong to the cgroup specified and run on the 
     450                          designated cpu. 
     451 
     452                menuconfig KERNEL_CGROUP_SCHED 
     453                        bool "Group CPU scheduler" 
     454                        default n 
     455                        help 
     456                          This feature lets CPU scheduler recognize task groups and control CPU 
     457                          bandwidth allocation to such task groups. It uses cgroups to group 
     458                          tasks. 
     459 
     460                if KERNEL_CGROUP_SCHED 
     461 
     462                        config KERNEL_FAIR_GROUP_SCHED 
     463                                bool "Group scheduling for SCHED_OTHER" 
     464                                default n 
     465 
     466                        config KERNEL_CFS_BANDWIDTH 
     467                                bool "CPU bandwidth provisioning for FAIR_GROUP_SCHED" 
     468                                default n 
     469                                depends on KERNEL_FAIR_GROUP_SCHED 
     470                                help 
     471                                  This option allows users to define CPU bandwidth rates (limits) for 
     472                                  tasks running within the fair group scheduler.  Groups with no limit 
     473                                  set are considered to be unconstrained and will run with no 
     474                                  restriction. 
     475                                  See tip/Documentation/scheduler/sched-bwc.txt for more information. 
     476 
     477                        config KERNEL_RT_GROUP_SCHED 
     478                                bool "Group scheduling for SCHED_RR/FIFO" 
     479                                default n 
     480                                help 
     481                                  This feature lets you explicitly allocate real CPU bandwidth 
     482                                  to task groups. If enabled, it will also make it impossible to 
     483                                  schedule realtime tasks for non-root users until you allocate 
     484                                  realtime bandwidth for them. 
     485 
     486                endif 
     487 
     488                config KERNEL_BLK_CGROUP 
     489                        bool "Block IO controller" 
     490                        default y 
     491                        help 
     492                          Generic block IO controller cgroup interface. This is the common 
     493                          cgroup interface which should be used by various IO controlling 
     494                          policies. 
     495 
     496                          Currently, CFQ IO scheduler uses it to recognize task groups and 
     497                          control disk bandwidth allocation (proportional time slice allocation) 
     498                          to such task groups. It is also used by bio throttling logic in 
     499                          block layer to implement upper limit in IO rates on a device. 
     500 
     501                          This option only enables generic Block IO controller infrastructure. 
     502                          One needs to also enable actual IO controlling logic/policy. For 
     503                          enabling proportional weight division of disk bandwidth in CFQ, set 
     504                          CONFIG_CFQ_GROUP_IOSCHED=y; for enabling throttling policy, set 
     505                          CONFIG_BLK_DEV_THROTTLING=y. 
     506 
     507                config KERNEL_DEBUG_BLK_CGROUP 
     508                        bool "Enable Block IO controller debugging" 
     509                        default n 
     510                        depends on KERNEL_BLK_CGROUP 
     511                        help 
     512                          Enable some debugging help. Currently it exports additional stat 
     513                          files in a cgroup which can be useful for debugging. 
     514 
     515                config KERNEL_NET_CLS_CGROUP 
     516                        bool "Control Group Classifier" 
     517                        default y 
     518 
     519                config KERNEL_NETPRIO_CGROUP 
     520                        bool "Network priority cgroup" 
     521                        default y 
     522 
     523        endif 
    410524 
    411525        # 
     
    413527        # 
    414528 
    415         config KERNEL_UTS_NS 
    416                 bool 
    417                 depends on KERNEL_NAMESPACES 
    418  
    419         config KERNEL_IPC_NS 
    420                 bool 
    421                 depends on KERNEL_NAMESPACES 
    422  
    423         config KERNEL_USER_NS 
    424                 bool 
    425                 depends on KERNEL_NAMESPACES 
    426  
    427         config KERNEL_PID_NS 
    428                 bool 
    429                 depends on KERNEL_NAMESPACES 
    430  
    431         config KERNEL_NET_NS 
    432                 bool 
    433                 depends on KERNEL_NAMESPACES 
    434  
    435         config KERNEL_DEVPTS_MULTIPLE_INSTANCES 
    436                 bool 
    437                 depends on KERNEL_NAMESPACES 
    438  
    439529        config KERNEL_NAMESPACES 
    440530                bool "Enable kernel namespaces" 
    441531                default n 
    442                 select KERNEL_UTS_NS 
    443                 select KERNEL_IPC_NS 
    444                 select KERNEL_USER_NS 
    445                 select KERNEL_PID_NS 
    446                 select KERNEL_NET_NS 
    447                 select KERNEL_DEVPTS_MULTIPLE_INSTANCES 
    448  
     532 
     533        if KERNEL_NAMESPACES 
     534 
     535                config KERNEL_UTS_NS 
     536                        bool "UTS namespace" 
     537                        default y 
     538                        help 
     539                          In this namespace tasks see different info provided 
     540                          with the uname() system call 
     541 
     542                config KERNEL_IPC_NS 
     543                        bool "IPC namespace" 
     544                        default y 
     545                        help 
     546                          In this namespace tasks work with IPC ids which correspond to 
     547                          different IPC objects in different namespaces. 
     548 
     549                config KERNEL_USER_NS 
     550                        bool "User namespace (EXPERIMENTAL)" 
     551                        default y 
     552                        help 
     553                          This allows containers, i.e. vservers, to use user namespaces 
     554                          to provide different user info for different servers. 
     555 
     556                config KERNEL_PID_NS 
     557                        bool "PID Namespaces" 
     558                        default y 
     559                        help 
     560                          Support process id namespaces. This allows having multiple 
     561                          processes with the same pid as long as they are in different 
     562                          pid namespaces. This is a building block of containers. 
     563 
     564                config KERNEL_NET_NS 
     565                        bool "Network namespace" 
     566                        default y 
     567                        help 
     568                          Allow user space to create what appear to be multiple instances 
     569                          of the network stack. 
     570 
     571                config KERNEL_DEVPTS_MULTIPLE_INSTANCES 
     572                        bool "Support multiple instances of devpts" 
     573                        default y 
     574                        help 
     575                          Enable support for multiple instances of devpts filesystem. 
     576                          If you want to have isolated PTY namespaces (eg: in containers), 
     577                          say Y here. Otherwise, say N. If enabled, each mount of devpts 
     578                          filesystem with the '-o newinstance' option will create an 
     579                          independent PTY namespace. 
     580 
     581        endif 
    449582 
    450583        comment "Package build options" 
Note: See TracChangeset for help on using the changeset viewer.