sched_autogroup.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    1 #ifdef CONFIG_SCHED_AUTOGROUP
    2 
    3 #include <linux/proc_fs.h>
    4 #include <linux/seq_file.h>
    5 #include <linux/kallsyms.h>
    6 #include <linux/utsname.h>
    7 
    8 unsigned int __read_mostly sysctl_sched_autogroup_enabled = 1;
    9 static struct autogroup autogroup_default;
   10 static atomic_t autogroup_seq_nr;
   11 
   12 static void __init autogroup_init(struct task_struct *init_task)
   13 {
   14         autogroup_default.tg = &root_task_group;
   15         kref_init(&autogroup_default.kref);
   16         init_rwsem(&autogroup_default.lock);
   17         init_task->signal->autogroup = &autogroup_default;
   18 }
   19 
   20 static inline void autogroup_free(struct task_group *tg)
   21 {
   22         kfree(tg->autogroup);
   23 }
   24 
   25 static inline void autogroup_destroy(struct kref *kref)
   26 {
   27         struct autogroup *ag = container_of(kref, struct autogroup, kref);
   28 
   29 #ifdef CONFIG_RT_GROUP_SCHED
   30         /* We've redirected RT tasks to the root task group... */
   31         ag->tg->rt_se = NULL;
   32         ag->tg->rt_rq = NULL;
   33 #endif
   34         sched_destroy_group(ag->tg);
   35 }
   36 
   37 static inline void autogroup_kref_put(struct autogroup *ag)
   38 {
   39         kref_put(&ag->kref, autogroup_destroy);
   40 }
   41 
   42 static inline struct autogroup *autogroup_kref_get(struct autogroup *ag)
   43 {
   44         kref_get(&ag->kref);
   45         return ag;
   46 }
   47 
   48 static inline struct autogroup *autogroup_task_get(struct task_struct *p)
   49 {
   50         struct autogroup *ag;
   51         unsigned long flags;
   52 
   53         if (!lock_task_sighand(p, &flags))
   54                 return autogroup_kref_get(&autogroup_default);
   55 
   56         ag = autogroup_kref_get(p->signal->autogroup);
   57         unlock_task_sighand(p, &flags);
   58 
   59         return ag;
   60 }
   61 
   62 #ifdef CONFIG_RT_GROUP_SCHED
   63 static void free_rt_sched_group(struct task_group *tg);
   64 #endif
   65 
   66 static inline struct autogroup *autogroup_create(void)
   67 {
   68         struct autogroup *ag = kzalloc(sizeof(*ag), GFP_KERNEL);
   69         struct task_group *tg;
   70 
   71         if (!ag)
   72                 goto out_fail;
   73 
   74         tg = sched_create_group(&root_task_group);
   75 
   76         if (IS_ERR(tg))
   77                 goto out_free;
   78 
   79         kref_init(&ag->kref);
   80         init_rwsem(&ag->lock);
   81         ag->id = atomic_inc_return(&autogroup_seq_nr);
   82         ag->tg = tg;
   83 #ifdef CONFIG_RT_GROUP_SCHED
   84         /*
   85          * Autogroup RT tasks are redirected to the root task group
   86          * so we don't have to move tasks around upon policy change,
   87          * or flail around trying to allocate bandwidth on the fly.
   88          * A bandwidth exception in __sched_setscheduler() allows
   89          * the policy change to proceed.  Thereafter, task_group()
   90          * returns &root_task_group, so zero bandwidth is required.
   91          */
   92         free_rt_sched_group(tg);
   93         tg->rt_se = root_task_group.rt_se;
   94         tg->rt_rq = root_task_group.rt_rq;
   95 #endif
   96         tg->autogroup = ag;
   97 
   98         return ag;
   99 
  100 out_free:
  101         kfree(ag);
  102 out_fail:
  103         if (printk_ratelimit()) {
  104                 printk(KERN_WARNING "autogroup_create: %s failure.\n",
  105                         ag ? "sched_create_group()" : "kmalloc()");
  106         }
  107 
  108         return autogroup_kref_get(&autogroup_default);
  109 }
  110 
  111 static inline bool
  112 task_wants_autogroup(struct task_struct *p, struct task_group *tg)
  113 {
  114         if (tg != &root_task_group)
  115                 return false;
  116 
  117         if (p->sched_class != &fair_sched_class)
  118                 return false;
  119 
  120         /*
  121          * We can only assume the task group can't go away on us if
  122          * autogroup_move_group() can see us on ->thread_group list.
  123          */
  124         if (p->flags & PF_EXITING)
  125                 return false;
  126 
  127         return true;
  128 }
  129 
  130 static inline bool task_group_is_autogroup(struct task_group *tg)
  131 {
  132         return !!tg->autogroup;
  133 }
  134 
  135 static inline struct task_group *
  136 autogroup_task_group(struct task_struct *p, struct task_group *tg)
  137 {
  138         int enabled = ACCESS_ONCE(sysctl_sched_autogroup_enabled);
  139 
  140         if (enabled && task_wants_autogroup(p, tg))
  141                 return p->signal->autogroup->tg;
  142 
  143         return tg;
  144 }
  145 
  146 static void
  147 autogroup_move_group(struct task_struct *p, struct autogroup *ag)
  148 {
  149         struct autogroup *prev;
  150         struct task_struct *t;
  151         unsigned long flags;
  152 
  153         BUG_ON(!lock_task_sighand(p, &flags));
  154 
  155         prev = p->signal->autogroup;
  156         if (prev == ag) {
  157                 unlock_task_sighand(p, &flags);
  158                 return;
  159         }
  160 
  161         p->signal->autogroup = autogroup_kref_get(ag);
  162 
  163         if (!ACCESS_ONCE(sysctl_sched_autogroup_enabled))
  164                 goto out;
  165 
  166         t = p;
  167         do {
  168                 sched_move_task(t);
  169         } while_each_thread(p, t);
  170 
  171 out:
  172         unlock_task_sighand(p, &flags);
  173         autogroup_kref_put(prev);
  174 }
  175 
  176 /* Allocates GFP_KERNEL, cannot be called under any spinlock */
  177 void sched_autogroup_create_attach(struct task_struct *p)
  178 {
  179         struct autogroup *ag = autogroup_create();
  180 
  181         autogroup_move_group(p, ag);
  182         /* drop extra reference added by autogroup_create() */
  183         autogroup_kref_put(ag);
  184 }
  185 EXPORT_SYMBOL(sched_autogroup_create_attach);
  186 
  187 /* Cannot be called under siglock.  Currently has no users */
  188 void sched_autogroup_detach(struct task_struct *p)
  189 {
  190         autogroup_move_group(p, &autogroup_default);
  191 }
  192 EXPORT_SYMBOL(sched_autogroup_detach);
  193 
  194 void sched_autogroup_fork(struct signal_struct *sig)
  195 {
  196         sig->autogroup = autogroup_task_get(current);
  197 }
  198 
  199 void sched_autogroup_exit(struct signal_struct *sig)
  200 {
  201         autogroup_kref_put(sig->autogroup);
  202 }
  203 
  204 static int __init setup_autogroup(char *str)
  205 {
  206         sysctl_sched_autogroup_enabled = 0;
  207 
  208         return 1;
  209 }
  210 
  211 __setup("noautogroup", setup_autogroup);
  212 
  213 #ifdef CONFIG_PROC_FS
  214 
  215 int proc_sched_autogroup_set_nice(struct task_struct *p, int *nice)
  216 {
  217         static unsigned long next = INITIAL_JIFFIES;
  218         struct autogroup *ag;
  219         int err;
  220 
  221         if (*nice < -20 || *nice > 19)
  222                 return -EINVAL;
  223 
  224         err = security_task_setnice(current, *nice);
  225         if (err)
  226                 return err;
  227 
  228         if (*nice < 0 && !can_nice(current, *nice))
  229                 return -EPERM;
  230 
  231         /* this is a heavy operation taking global locks.. */
  232         if (!capable(CAP_SYS_ADMIN) && time_before(jiffies, next))
  233                 return -EAGAIN;
  234 
  235         next = HZ / 10 + jiffies;
  236         ag = autogroup_task_get(p);
  237 
  238         down_write(&ag->lock);
  239         err = sched_group_set_shares(ag->tg, prio_to_weight[*nice + 20]);
  240         if (!err)
  241                 ag->nice = *nice;
  242         up_write(&ag->lock);
  243 
  244         autogroup_kref_put(ag);
  245 
  246         return err;
  247 }
  248 
  249 void proc_sched_autogroup_show_task(struct task_struct *p, struct seq_file *m)
  250 {
  251         struct autogroup *ag = autogroup_task_get(p);
  252 
  253         if (!task_group_is_autogroup(ag->tg))
  254                 goto out;
  255 
  256         down_read(&ag->lock);
  257         seq_printf(m, "/autogroup-%ld nice %d\n", ag->id, ag->nice);
  258         up_read(&ag->lock);
  259 
  260 out:
  261         autogroup_kref_put(ag);
  262 }
  263 #endif /* CONFIG_PROC_FS */
  264 
  265 #ifdef CONFIG_SCHED_DEBUG
  266 static inline int autogroup_path(struct task_group *tg, char *buf, int buflen)
  267 {
  268         if (!task_group_is_autogroup(tg))
  269                 return 0;
  270 
  271         return snprintf(buf, buflen, "%s-%ld", "/autogroup", tg->autogroup->id);
  272 }
  273 #endif /* CONFIG_SCHED_DEBUG */
  274 
  275 #endif /* CONFIG_SCHED_AUTOGROUP */

Cache object: b20a4ac99e62189e139dff6e5bb51efb

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/kernel/sched_autogroup.c

FreeBSD/Linux Kernel Cross Reference
sys/kernel/sched_autogroup.c