kernel/ckrm/ckrmutils.c

   1 /* ckrmutils.c - Utility functions for CKRM
   2  *
   3  * Copyright (C) Chandra Seetharaman,  IBM Corp. 2003
   4  *           (C) Hubertus Franke    ,  IBM Corp. 2004
   5  *
   6  * Provides simple utility functions for the core module, CE and resource
   7  * controllers.
   8  *
   9  * Latest version, more details at http://ckrm.sf.net
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  */
  17
  18 /* Changes
  19  *
  20  * 13 Nov 2003
  21  *        Created
  22  */
  23
  24 #include <linux/mm.h>
  25 #include <linux/err.h>
  26 #include <linux/mount.h>
  27 #include <linux/module.h>
  28 #include <linux/ckrm_rc.h>
  29
  30 int get_exe_path_name(struct task_struct *tsk, char *buf, int buflen)
  31 {
  32         struct vm_area_struct *vma;
  33         struct vfsmount *mnt;
  34         struct mm_struct *mm = get_task_mm(tsk);
  35         struct dentry *dentry;
  36         char *lname;
  37         int rc = 0;
  38
  39         *buf = '\0';
  40         if (!mm) {
  41                 return -EINVAL;
  42         }
  43
  44         down_read(&mm->mmap_sem);
  45         vma = mm->mmap;
  46         while (vma) {
  47                 if ((vma->vm_flags & VM_EXECUTABLE) && vma->vm_file) {
  48                         dentry = dget(vma->vm_file->f_dentry);
  49                         mnt = mntget(vma->vm_file->f_vfsmnt);
  50                         lname = d_path(dentry, mnt, buf, buflen);
  51                         if (!IS_ERR(lname)) {
  52                                 strncpy(buf, lname, strlen(lname) + 1);
  53                         } else {
  54                                 rc = (int)PTR_ERR(lname);
  55                         }
  56                         mntput(mnt);
  57                         dput(dentry);
  58                         break;
  59                 }
  60                 vma = vma->vm_next;
  61         }
  62         up_read(&mm->mmap_sem);
  63         mmput(mm);
  64         return rc;
  65 }
  66
  67 /*
  68  * must be called with cnt_lock of parres held
  69  * Caller is responsible for making sure that the new guarantee doesn't
  70  * overflow parent's total guarantee.
  71  */
  72 void child_guarantee_changed(struct ckrm_shares *parent, int cur, int new)
  73 {
  74         if (new == cur || !parent) {
  75                 return;
  76         }
  77         if (new != CKRM_SHARE_DONTCARE) {
  78                 parent->unused_guarantee -= new;
  79         }
  80         if (cur != CKRM_SHARE_DONTCARE) {
  81                 parent->unused_guarantee += cur;
  82         }
  83         return;
  84 }
  85
  86 /*
  87  * must be called with cnt_lock of parres held
  88  * Caller is responsible for making sure that the new limit is not more
  89  * than parent's max_limit
  90  */
  91 void child_maxlimit_changed(struct ckrm_shares *parent, int new_limit)
  92 {
  93         if (parent && parent->cur_max_limit < new_limit) {
  94                 parent->cur_max_limit = new_limit;
  95         }
  96         return;
  97 }
  98
  99 /*
 100  * Caller is responsible for holding any lock to protect the data
 101  * structures passed to this function
 102  */
 103 int
 104 set_shares(struct ckrm_shares *new, struct ckrm_shares *cur,
 105            struct ckrm_shares *par)
 106 {
 107         int rc = -EINVAL;
 108         int cur_usage_guar = cur->total_guarantee - cur->unused_guarantee;
 109         int increase_by;
 110
 111         if (cur->my_guarantee < 0) // DONTCARE or UNCHANGED
 112                 increase_by = new->my_guarantee;
 113         else
 114                 increase_by = new->my_guarantee - cur->my_guarantee;
 115
 116         // Check total_guarantee for correctness
 117         if (new->total_guarantee <= CKRM_SHARE_DONTCARE) {
 118                 goto set_share_err;
 119         } else if (new->total_guarantee == CKRM_SHARE_UNCHANGED) {
 120                 ;               // do nothing
 121         } else if (cur_usage_guar > new->total_guarantee) {
 122                 goto set_share_err;
 123         }
 124         // Check max_limit for correctness
 125         if (new->max_limit <= CKRM_SHARE_DONTCARE) {
 126                 goto set_share_err;
 127         } else if (new->max_limit == CKRM_SHARE_UNCHANGED) {
 128                 ;               // do nothing
 129         } else if (cur->cur_max_limit > new->max_limit) {
 130                 goto set_share_err;
 131         }
 132         // Check my_guarantee for correctness
 133         if (new->my_guarantee == CKRM_SHARE_UNCHANGED) {
 134                 ;               // do nothing
 135         } else if (new->my_guarantee == CKRM_SHARE_DONTCARE) {
 136                 ;               // do nothing
 137         } else if (par && increase_by > par->unused_guarantee) {
 138                 goto set_share_err;
 139         }
 140         // Check my_limit for correctness
 141         if (new->my_limit == CKRM_SHARE_UNCHANGED) {
 142                 ;               // do nothing
 143         } else if (new->my_limit == CKRM_SHARE_DONTCARE) {
 144                 ;               // do nothing
 145         } else if (par && new->my_limit > par->max_limit) {
 146                 // I can't get more limit than my parent's limit
 147                 goto set_share_err;
 148
 149         }
 150         // make sure guarantee is lesser than limit
 151         if (new->my_limit == CKRM_SHARE_DONTCARE) {
 152                 ;               // do nothing
 153         } else if (new->my_limit == CKRM_SHARE_UNCHANGED) {
 154                 if (new->my_guarantee == CKRM_SHARE_DONTCARE) {
 155                         ;       // do nothing
 156                 } else if (new->my_guarantee == CKRM_SHARE_UNCHANGED) {
 157                         ;       // do nothing earlier setting would've
 158                                 // taken care of it
 159                 } else if (new->my_guarantee > cur->my_limit) {
 160                         goto set_share_err;
 161                 }
 162         } else {                // new->my_limit has a valid value
 163                 if (new->my_guarantee == CKRM_SHARE_DONTCARE) {
 164                         ;       // do nothing
 165                 } else if (new->my_guarantee == CKRM_SHARE_UNCHANGED) {
 166                         if (cur->my_guarantee > new->my_limit) {
 167                                 goto set_share_err;
 168                         }
 169                 } else if (new->my_guarantee > new->my_limit) {
 170                         goto set_share_err;
 171                 }
 172         }
 173
 174         if (new->my_guarantee != CKRM_SHARE_UNCHANGED) {
 175                 child_guarantee_changed(par, cur->my_guarantee,
 176                                         new->my_guarantee);
 177                 cur->my_guarantee = new->my_guarantee;
 178         }
 179
 180         if (new->my_limit != CKRM_SHARE_UNCHANGED) {
 181                 child_maxlimit_changed(par, new->my_limit);
 182                 cur->my_limit = new->my_limit;
 183         }
 184
 185         if (new->total_guarantee != CKRM_SHARE_UNCHANGED) {
 186                 cur->unused_guarantee = new->total_guarantee - cur_usage_guar;
 187                 cur->total_guarantee = new->total_guarantee;
 188         }
 189
 190         if (new->max_limit != CKRM_SHARE_UNCHANGED) {
 191                 cur->max_limit = new->max_limit;
 192         }
 193
 194         rc = 0;
 195       set_share_err:
 196         return rc;
 197 }
 198
 199 EXPORT_SYMBOL(get_exe_path_name);
 200 EXPORT_SYMBOL(child_guarantee_changed);
 201 EXPORT_SYMBOL(child_maxlimit_changed);
 202 EXPORT_SYMBOL(set_shares);