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 /*
 101  * Caller is responsible for holding any lock to protect the data
 102  * structures passed to this function
 103  */
 104 int
 105 set_shares(struct ckrm_shares *new, struct ckrm_shares *cur,
 106            struct ckrm_shares *par)
 107 {
 108         int rc = -EINVAL;
 109         int cur_usage_guar = cur->total_guarantee - cur->unused_guarantee;
 110         int increase_by = new->my_guarantee - cur->my_guarantee;
 111
 112         // Check total_guarantee for correctness
 113         if (new->total_guarantee <= CKRM_SHARE_DONTCARE) {
 114                 printk(KERN_ERR "new->total_guarantee %d <= CKRM_SHARE_DONTCARE\n",
 115                     new->total_guarantee);
 116                 goto set_share_err;
 117         } else if (new->total_guarantee == CKRM_SHARE_UNCHANGED) {
 118                 ;               // do nothing
 119         } else if (cur_usage_guar > new->total_guarantee) {
 120                 printk(KERN_ERR "cur_usage_guar %d > new->total_guarantee %d\n",
 121                     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                 printk(KERN_ERR "new->max_limit %d <= CKRM_SHARE_DONTCARE\n",
 127                     new->max_limit);
 128                 goto set_share_err;
 129         } else if (new->max_limit == CKRM_SHARE_UNCHANGED) {
 130                 ;               // do nothing
 131         } else if (cur->cur_max_limit > new->max_limit) {
 132                 printk(KERN_ERR "cur->cur_max_limit %d > new->max_limit %d\n",
 133                     cur->cur_max_limit, new->max_limit);
 134                 goto set_share_err;
 135         }
 136         // Check my_guarantee for correctness
 137         if (new->my_guarantee == CKRM_SHARE_UNCHANGED) {
 138                 ;               // do nothing
 139         } else if (new->my_guarantee == CKRM_SHARE_DONTCARE) {
 140                 ;               // do nothing
 141         } else if (par && increase_by > par->unused_guarantee) {
 142                 printk(KERN_ERR "increase_by %d > par->unused_guarantee %d\n",
 143                     increase_by, par->unused_guarantee);
 144                 goto set_share_err;
 145         }
 146         // Check my_limit for correctness
 147         if (new->my_limit == CKRM_SHARE_UNCHANGED) {
 148                 ;               // do nothing
 149         } else if (new->my_limit == CKRM_SHARE_DONTCARE) {
 150                 ;               // do nothing
 151         } else if (par && new->my_limit > par->max_limit) {
 152                 // I can't get more limit than my parent's limit
 153                 printk(KERN_ERR "new->my_limit %d > par->max_limit %d\n",
 154                     new->my_limit,par->max_limit);
 155                 goto set_share_err;
 156
 157         }
 158         // make sure guarantee is lesser than limit
 159         if (new->my_limit == CKRM_SHARE_DONTCARE) {
 160                 ;               // do nothing
 161         } else if (new->my_limit == CKRM_SHARE_UNCHANGED) {
 162                 if (new->my_guarantee == CKRM_SHARE_DONTCARE) {
 163                         ;       // do nothing
 164                 } else if (new->my_guarantee == CKRM_SHARE_UNCHANGED) {
 165                         ;       // do nothing earlier setting would've
 166                                 // taken care of it
 167                 } else if (new->my_guarantee > cur->my_limit) {
 168                         printk(KERN_ERR "new->my_guarantee %d > cur->my_limit %d\n",
 169                             new->my_guarantee,par->max_limit);
 170                         goto set_share_err;
 171                 }
 172         } else {                // new->my_limit has a valid value
 173                 if (new->my_guarantee == CKRM_SHARE_DONTCARE) {
 174                         ;       // do nothing
 175                 } else if (new->my_guarantee == CKRM_SHARE_UNCHANGED) {
 176                         if (cur->my_guarantee > new->my_limit) {
 177                                 printk(KERN_ERR "cur->my_guarantee %d > new->my_limit %d\n",
 178                                     cur->my_guarantee,new->my_limit);
 179                                 goto set_share_err;
 180                         }
 181                 } else if (new->my_guarantee > new->my_limit) {
 182                         printk(KERN_ERR "new->my_guarantee %d > new->my_limit %d\n",
 183                             new->my_guarantee,new->my_limit);
 184                         goto set_share_err;
 185                 }
 186         }
 187
 188         if (new->my_guarantee != CKRM_SHARE_UNCHANGED) {
 189                 child_guarantee_changed(par, cur->my_guarantee,
 190                                         new->my_guarantee);
 191                 cur->my_guarantee = new->my_guarantee;
 192         }
 193
 194         if (new->my_limit != CKRM_SHARE_UNCHANGED) {
 195                 child_maxlimit_changed(par, new->my_limit);
 196                 cur->my_limit = new->my_limit;
 197         }
 198
 199         if (new->total_guarantee != CKRM_SHARE_UNCHANGED) {
 200                 cur->unused_guarantee = new->total_guarantee - cur_usage_guar;
 201                 cur->total_guarantee = new->total_guarantee;
 202         }
 203
 204         if (new->max_limit != CKRM_SHARE_UNCHANGED) {
 205                 cur->max_limit = new->max_limit;
 206         }
 207
 208         rc = 0;
 209       set_share_err:
 210         return rc;
 211 }
 212
 213 EXPORT_SYMBOL(get_exe_path_name);
 214 EXPORT_SYMBOL(child_guarantee_changed);
 215 EXPORT_SYMBOL(child_maxlimit_changed);
 216 EXPORT_SYMBOL(set_shares);