context.c

Go to the documentation of this file.
00001 // Copyright 2005-2006 Benedikt Böhm <hollow@gentoo.org>
00002 //
00003 // This program is free software; you can redistribute it and/or modify
00004 // it under the terms of the GNU General Public License as published by
00005 // the Free Software Foundation; either version 2 of the License, or
00006 // (at your option) any later version.
00007 //
00008 // This program is distributed in the hope that it will be useful,
00009 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00010 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00011 // GNU General Public License for more details.
00012 //
00013 // You should have received a copy of the GNU General Public License
00014 // along with this program; if not, write to the
00015 // Free Software Foundation, Inc.,
00016 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
00017 
00018 #include <stdint.h>
00019 #include <errno.h>
00020 
00021 #include "linux/vserver/switch.h"
00022 #include "linux/vserver/context_cmd.h"
00023 #include "linux/vserver/cvirt_cmd.h"
00024 #include "linux/vserver/signal_cmd.h"
00025 
00026 #include "vserver.h"
00027 
00028 /* we don't want to use those from libc, but don't want lucid either */
00029 static inline
00030 int str_len(const char *str)
00031 {
00032         int i = 0;
00033 
00034         while (*str++)
00035                 i++;
00036 
00037         return i;
00038 }
00039 
00040 static inline
00041 void str_zero(void *str, int n)
00042 {
00043         char *p = str;
00044 
00045         while (n--)
00046                 *p++ = 0;
00047 }
00048 
00049 static inline
00050 int str_cpyn(void *dst, const void *src, int n)
00051 {
00052         char *d = dst;
00053         const char *s = src;
00054 
00055         while (n--)
00056                 *d++ = *s++;
00057 
00058         return d - (char *) dst;
00059 }
00060 
00061 int vx_create(xid_t xid, vx_flags_t *data)
00062 {
00063         struct vcmd_ctx_create kdata = {
00064                 .flagword = 0,
00065         };
00066 
00067         if (data)
00068                 kdata.flagword = data->flags;
00069 
00070         return vserver(VCMD_ctx_create, xid, &kdata);
00071 }
00072 
00073 int vx_migrate(xid_t xid, vx_flags_t *data)
00074 {
00075         struct vcmd_ctx_migrate kdata = {
00076                 .flagword = 0,
00077         };
00078 
00079         if (data)
00080                 kdata.flagword = data->flags;
00081 
00082         return vserver(VCMD_ctx_migrate, xid, &kdata);
00083 }
00084 
00085 int vx_task_xid(pid_t pid)
00086 {
00087         return vserver(VCMD_task_xid, pid, NULL);
00088 }
00089 
00090 int vx_info(xid_t xid, vx_info_t *data)
00091 {
00092         struct vcmd_vx_info_v0 kdata;
00093 
00094         int rc = vserver(VCMD_vx_info, xid, &kdata);
00095 
00096         if (rc == -1)
00097                 return rc;
00098 
00099         if (data) {
00100                 data->xid     = kdata.xid;
00101                 data->initpid = kdata.initpid;
00102         }
00103 
00104         return rc;
00105 }
00106 
00107 int vx_stat(xid_t xid, vx_stat_t *data)
00108 {
00109         int rc;
00110         struct vcmd_ctx_stat_v0 kdata1;
00111         struct vcmd_virt_stat_v0 kdata2;
00112 
00113         rc = vserver(VCMD_ctx_stat, xid, &kdata1);
00114 
00115         if (rc == -1)
00116                 return rc;
00117 
00118         rc = vserver(VCMD_virt_stat, xid, &kdata2);
00119 
00120         if (rc == -1)
00121                 return rc;
00122 
00123         if (data) {
00124                 data->usecnt     = kdata1.usecnt;
00125                 data->tasks      = kdata1.tasks;
00126                 data->nr_threads = kdata2.nr_threads;
00127                 data->nr_running = kdata2.nr_running;
00128                 data->nr_unintr  = kdata2.nr_uninterruptible;
00129                 data->nr_onhold  = kdata2.nr_onhold;
00130                 data->nr_forks   = kdata2.nr_forks;
00131                 data->load[0]    = kdata2.load[0];
00132                 data->load[1]    = kdata2.load[1];
00133                 data->load[2]    = kdata2.load[2];
00134                 data->offset     = kdata2.offset;
00135                 data->uptime     = kdata2.uptime;
00136         }
00137 
00138         return rc;
00139 }
00140 
00141 int vx_bcaps_set(xid_t xid, vx_flags_t *data)
00142 {
00143         struct vcmd_bcaps kdata;
00144 
00145         if (!data)
00146                 return errno = EINVAL, -1;
00147 
00148         kdata.bcaps = data->flags;
00149         kdata.bmask = data->mask;
00150 
00151         return vserver(VCMD_set_bcaps, xid, &kdata);
00152 }
00153 
00154 int vx_bcaps_get(xid_t xid, vx_flags_t *data)
00155 {
00156         struct vcmd_bcaps kdata;
00157 
00158         if (!data)
00159                 return errno = EINVAL, -1;
00160 
00161         int rc = vserver(VCMD_get_bcaps, xid, &kdata);
00162 
00163         if (rc == -1)
00164                 return rc;
00165 
00166         data->flags = kdata.bcaps;
00167         data->mask  = kdata.bmask;
00168 
00169         return rc;
00170 }
00171 
00172 int vx_ccaps_set(xid_t xid, vx_flags_t *data)
00173 {
00174         struct vcmd_ctx_caps_v1 kdata;
00175 
00176         if (!data)
00177                 return errno = EINVAL, -1;
00178 
00179         kdata.ccaps = data->flags;
00180         kdata.cmask = data->mask;
00181 
00182         return vserver(VCMD_set_ccaps, xid, &kdata);
00183 }
00184 
00185 int vx_ccaps_get(xid_t xid, vx_flags_t *data)
00186 {
00187         struct vcmd_ctx_caps_v1 kdata;
00188 
00189         if (!data)
00190                 return errno = EINVAL, -1;
00191 
00192         int rc = vserver(VCMD_get_ccaps, xid, &kdata);
00193 
00194         if (rc == -1)
00195                 return rc;
00196 
00197         data->flags = kdata.ccaps;
00198         data->mask  = kdata.cmask;
00199 
00200         return rc;
00201 }
00202 
00203 int vx_flags_set(xid_t xid, vx_flags_t *data)
00204 {
00205         struct vcmd_ctx_flags_v0 kdata;
00206 
00207         if (!data)
00208                 return errno = EINVAL, -1;
00209 
00210         kdata.flagword = data->flags;
00211         kdata.mask     = data->mask;
00212 
00213         return vserver(VCMD_set_cflags, xid, &kdata);
00214 }
00215 
00216 int vx_flags_get(xid_t xid, vx_flags_t *data)
00217 {
00218         struct vcmd_ctx_flags_v0 kdata;
00219 
00220         if (!data)
00221                 return errno = EINVAL, -1;
00222 
00223         int rc = vserver(VCMD_get_cflags, xid, &kdata);
00224 
00225         if (rc == -1)
00226                 return rc;
00227 
00228         data->flags = kdata.flagword;
00229         data->mask  = kdata.mask;
00230 
00231         return rc;
00232 }
00233 
00234 int vx_uname_set(xid_t xid, vx_uname_t *data)
00235 {
00236         struct vcmd_vhi_name_v0 kdata;
00237 
00238         if (!data)
00239                 return errno = EINVAL, -1;
00240 
00241         if (str_len(data->value) >= sizeof(kdata.name))
00242                 return errno = EINVAL, -1;
00243 
00244         kdata.field = data->id;
00245 
00246         str_zero(kdata.name, sizeof(kdata.name));
00247         str_cpyn(kdata.name, data->value, sizeof(kdata.name) - 1);
00248 
00249         return vserver(VCMD_set_vhi_name, xid, &kdata);
00250 }
00251 
00252 int vx_uname_get(xid_t xid, vx_uname_t *data)
00253 {
00254         int rc;
00255         struct vcmd_vhi_name_v0 kdata;
00256 
00257         if (!data)
00258                 return errno = EINVAL, -1;
00259 
00260         kdata.field = data->id;
00261 
00262         rc = vserver(VCMD_get_vhi_name, xid, &kdata);
00263 
00264         if (rc == -1)
00265                 return rc;
00266 
00267         str_zero(data->value, sizeof(kdata.name));
00268         str_cpyn(data->value, kdata.name, sizeof(kdata.name) - 1);
00269 
00270         return rc;
00271 }
00272 
00273 int vx_kill(xid_t xid, pid_t pid, int sig)
00274 {
00275         struct vcmd_ctx_kill_v0 kdata;
00276 
00277         kdata.pid = pid;
00278         kdata.sig = sig;
00279 
00280         return vserver(VCMD_ctx_kill, xid, &kdata);
00281 }
00282 
00283 int vx_wait(xid_t xid, vx_wait_t *data)
00284 {
00285         struct vcmd_wait_exit_v0 kdata;
00286 
00287         int rc;
00288 
00289         rc = vserver(VCMD_wait_exit, xid, &kdata);
00290 
00291         if (rc == -1)
00292                 return -1;
00293 
00294         if (data) {
00295                 data->reboot_cmd = kdata.reboot_cmd;
00296                 data->exit_code  = kdata.exit_code;
00297         }
00298 
00299         return rc;
00300 }

Generated on Wed Jun 20 19:50:08 2007 for libvserver by  doxygen 1.5.2