cp/shell/cmd_store.c

   1 /*
   2  * (C) Copyright 2007-2010  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
   3  *
   4  * This file is released under the GPLv2.  See the COPYING file for more
   5  * details.
   6  */
   7
   8 /*
   9  *!!! STORE STORAGE
  10  *!! SYNTAX
  11  *! \cbstart
  12  *! \tok{\sc STOre} \tok{\sc STOrage} <address> <value>
  13  *! \cbend
  14  *!! XATNYS
  15  *!! AUTH G
  16  *!! PURPOSE
  17  *! Sets a word in guest's storage at address to value
  18  */
  19 static int cmd_store_storage(struct virt_sys *sys, char *cmd, int len)
  20 {
  21         int ret;
  22         u64 guest_addr, host_addr;
  23         u64 val = 0;
  24
  25         SHELL_CMD_AUTH(sys, G);
  26
  27         cmd = parse_addrspec(&guest_addr, NULL, cmd);
  28         if (IS_ERR(cmd)) {
  29                 con_printf(sys->con, "STORE: Invalid addr-spec\n");
  30                 return PTR_ERR(cmd);
  31         }
  32
  33         /* consume any extra whitespace */
  34         cmd = __consume_ws(cmd);
  35
  36         /* get the value */
  37         cmd = __extract_hex(cmd, &val);
  38         if (IS_ERR(cmd))
  39                 return PTR_ERR(cmd);
  40
  41         /*
  42          * round down to the nearest word
  43          */
  44         guest_addr &= ~((u64) 3ULL);
  45
  46         /* walk the page tables to find the real page frame */
  47         ret = virt2phy_current(guest_addr, &host_addr);
  48         if (ret) {
  49                 con_printf(sys->con, "STORE: Specified address is not part of "
  50                            "guest configuration\n");
  51                 return ret;
  52         }
  53
  54         *((u32*) host_addr) = (u32) val;
  55
  56         con_printf(sys->con, "Store complete.\n");
  57
  58         return 0;
  59 }
  60
  61 /*
  62  *!!! STORE GPR
  63  *!! SYNTAX
  64  *! \tok{\sc STOre} \tok{\sc Gpr} <gpr> <value>
  65  *!! XATNYS
  66  *!! AUTH G
  67  *!! PURPOSE
  68  *! Sets a guest's general purpose register to the specified value
  69  */
  70 static int cmd_store_gpr(struct virt_sys *sys, char *cmd, int len)
  71 {
  72         u64 *ptr = (u64*) &sys->task->cpu->regs.gpr;
  73         u64 val, gpr;
  74
  75         SHELL_CMD_AUTH(sys, G);
  76
  77         cmd = __extract_dec(cmd, &gpr);
  78         if (IS_ERR(cmd))
  79                 return PTR_ERR(cmd);
  80         if (gpr > 15)
  81                 return -EINVAL;
  82
  83         cmd = __consume_ws(cmd);
  84
  85         cmd = __extract_hex(cmd, &val);
  86         if (IS_ERR(cmd))
  87                 return PTR_ERR(cmd);
  88
  89         ptr[gpr] = val;
  90
  91         con_printf(sys->con, "Store complete.\n");
  92
  93         return 0;
  94 }
  95
  96 /*
  97  *!!! STORE FPR
  98  *!! SYNTAX
  99  *! \tok{\sc STOre} \tok{\sc Fpr} <fpr> <value>
 100  *!! XATNYS
 101  *!! AUTH G
 102  *!! PURPOSE
 103  *! Sets a guest's floating point register to the specified value
 104  */
 105 static int cmd_store_fpr(struct virt_sys *sys, char *cmd, int len)
 106 {
 107         u64 *ptr = (u64*) &sys->task->cpu->regs.fpr;
 108         u64 val, fpr;
 109
 110         SHELL_CMD_AUTH(sys, G);
 111
 112         cmd = __extract_dec(cmd, &fpr);
 113         if (IS_ERR(cmd))
 114                 return PTR_ERR(cmd);
 115         if (fpr > 15)
 116                 return -EINVAL;
 117
 118         cmd = __consume_ws(cmd);
 119
 120         cmd = __extract_hex(cmd, &val);
 121         if (IS_ERR(cmd))
 122                 return PTR_ERR(cmd);
 123
 124         ptr[fpr] = val;
 125
 126         con_printf(sys->con, "Store complete.\n");
 127
 128         return 0;
 129 }
 130
 131 /*
 132  *!!! STORE FPCR
 133  *!! SYNTAX
 134  *! \tok{\sc STOre} \tok{\sc FPCR} <value>
 135  *!! XATNYS
 136  *!! AUTH G
 137  *!! PURPOSE
 138  *! Sets a guest's floating point control register to the specified value
 139  */
 140 static int cmd_store_fpcr(struct virt_sys *sys, char *cmd, int len)
 141 {
 142         u64 val;
 143
 144         SHELL_CMD_AUTH(sys, G);
 145
 146         cmd = __extract_hex(cmd, &val);
 147         if (IS_ERR(cmd))
 148                 return PTR_ERR(cmd);
 149         if (val > 0xffffffffULL)
 150                 return -EINVAL;
 151
 152         sys->task->cpu->regs.fpcr = (u32) val;
 153
 154         con_printf(sys->con, "Store complete.\n");
 155
 156         return 0;
 157 }
 158
 159 /*
 160  *!!! STORE CR
 161  *!! SYNTAX
 162  *! \tok{\sc STOre} \tok{\sc Cr} <cr> <value>
 163  *!! XATNYS
 164  *!! AUTH G
 165  *!! PURPOSE
 166  *! Sets a guest's control register to the specified value
 167  */
 168 static int cmd_store_cr(struct virt_sys *sys, char *cmd, int len)
 169 {
 170         u64 *ptr = (u64*) &sys->task->cpu->sie_cb.gcr;
 171         u64 val, cr;
 172
 173         SHELL_CMD_AUTH(sys, G);
 174
 175         cmd = __extract_dec(cmd, &cr);
 176         if (IS_ERR(cmd))
 177                 return PTR_ERR(cmd);
 178         if (cr > 15)
 179                 return -EINVAL;
 180
 181         cmd = __consume_ws(cmd);
 182
 183         cmd = __extract_hex(cmd, &val);
 184         if (IS_ERR(cmd))
 185                 return PTR_ERR(cmd);
 186
 187         ptr[cr] = val;
 188
 189         con_printf(sys->con, "Store complete.\n");
 190
 191         return 0;
 192 }
 193
 194 /*
 195  *!!! STORE AR
 196  *!! SYNTAX
 197  *! \tok{\sc STOre} \tok{\sc Ar} <ar> <value>
 198  *!! XATNYS
 199  *!! AUTH G
 200  *!! PURPOSE
 201  *! Sets a guest's access register to the specified value
 202  */
 203 static int cmd_store_ar(struct virt_sys *sys, char *cmd, int len)
 204 {
 205         u32 *ptr = (u32*) &sys->task->cpu->regs.ar;
 206         u64 val, ar;
 207
 208         SHELL_CMD_AUTH(sys, G);
 209
 210         cmd = __extract_dec(cmd, &ar);
 211         if (IS_ERR(cmd))
 212                 return PTR_ERR(cmd);
 213         if (ar > 15)
 214                 return -EINVAL;
 215
 216         cmd = __consume_ws(cmd);
 217
 218         cmd = __extract_hex(cmd, &val);
 219         if (IS_ERR(cmd))
 220                 return PTR_ERR(cmd);
 221         if (val > 0xffffffffULL)
 222                 return -EINVAL;
 223
 224         ptr[ar] = val;
 225
 226         con_printf(sys->con, "Store complete.\n");
 227
 228         return 0;
 229 }
 230
 231 /*
 232  *!!! STORE PSW
 233  *!! SYNTAX
 234  *! \cbstart
 235  *! \tok{\sc STOre} \tok{\sc PSW}
 236  *!     \begin{stack} \\
 237  *!       \begin{stack} \\
 238  *!         \begin{stack} \\ <hexword1>
 239  *!         \end{stack} <hexword2>
 240  *!       \end{stack} <hexword3>
 241  *!     \end{stack}
 242  *! <hexword4>
 243  *! \cbend
 244  *!! XATNYS
 245  *!! AUTH G
 246  *!! PURPOSE
 247  *! \cbstart
 248  *! Alters all or a part of the PSW.
 249  *! \cbend
 250  *!! OPERANDS
 251  *! \cbstart
 252  *! \item[hexword...]
 253  *!   \textbf{For an ESA/390 guest:}
 254  *!
 255  *!   Alters all or part of the PSW with the data specified in hexword3
 256  *!   and hexword4.  If only hexword4 is specified, it is stored to PSW bits
 257  *!   32-63.  If hexword3 and hexword4 are specified, hexword3 is stored to
 258  *!   PSW bits 0-31, and hexword4 to PSW bits 32-63.
 259  *!
 260  *!   If more than two values are specified, the PSW remains unchanged and an
 261  *!   message indicating an error is printed.
 262  *!
 263  *!   \textbf{For a z/Architecture guest:}
 264  *!
 265  *!   If only one hexword4 is specified, PSW bits 96-127 are set to it.
 266  *!
 267  *!   If hexword3 and hexword4 are specified, PSW bits 64-95 are set to
 268  *!   hexword3, and bits 96-127 are set to hexword4.
 269  *!
 270  *!   If hexword2, hexword3, and hexword4 are specified, PSW bits 32-63 are
 271  *!   set to hexword2, bits 64-95 are set to hexword3, and bits 96-127 are
 272  *!   set to hexword4.
 273  *!
 274  *!   If hexword1, hexword2, hexword3, and hexword4 are specified, PSW bits
 275  *!   0-31 are set to hexword1, bits 32-63 are set to hexword2, bits 64-95
 276  *!   are set to hexword3, and bits 96-127 are set to hexword4.
 277  *! \cbend
 278  *!! SDNAREPO
 279  */
 280 static int cmd_store_psw(struct virt_sys *sys, char *cmd, int len)
 281 {
 282         u32 *ptr = (u32*) &sys->task->cpu->sie_cb.gpsw;
 283
 284         u64 new_words[4] = {0, 0, 0, 0};
 285         int cnt;
 286
 287         SHELL_CMD_AUTH(sys, G);
 288
 289         for (cnt=0; cnt<4; cnt++) {
 290                 cmd = __extract_hex(cmd, &new_words[cnt]);
 291                 if (IS_ERR(cmd))
 292                         break;
 293
 294                 cmd = __consume_ws(cmd);
 295         }
 296
 297         if (!cnt)
 298                 return -EINVAL;
 299
 300         if (!VCPU_ZARCH(sys->task->cpu)) {
 301                 /* ESA/390 mode */
 302                 if (cnt > 2) {
 303                         con_printf(sys->con, "STORE: ERROR ESA/390 PSW USES ONLY TWO WORDS\n");
 304                         return -EINVAL;
 305                 }
 306
 307                 /*
 308                  * This is a simple "hack" to make the stores go into the
 309                  * right place.  If he had a single word, we want it to go
 310                  * the the second word of the 16-byte PSW, not the 4th.
 311                  * Similarly, if we had two words, we want them to go into
 312                  * the first and second words of the 16-byte PSW.
 313                  */
 314                 cnt += 2;
 315         }
 316
 317         switch(cnt) {
 318                 case 4:
 319                         ptr[0] = (u32) new_words[0];
 320                         ptr[1] = (u32) new_words[1];
 321                         ptr[2] = (u32) new_words[2];
 322                         ptr[3] = (u32) new_words[3];
 323                         break;
 324                 case 3:
 325                         ptr[1] = (u32) new_words[0];
 326                         ptr[2] = (u32) new_words[1];
 327                         ptr[3] = (u32) new_words[2];
 328                         break;
 329                 case 2:
 330                         ptr[2] = (u32) new_words[0];
 331                         ptr[3] = (u32) new_words[1];
 332                         break;
 333                 case 1:
 334                         ptr[3] = (u32) new_words[0];
 335                         break;
 336                 case 0:
 337                         return -EINVAL;
 338         }
 339
 340         con_printf(sys->con, "Store complete.\n");
 341         return 0;
 342 }
 343
 344 static struct cpcmd cmd_tbl_store[] = {
 345         {"AR",          cmd_store_ar,           NULL},
 346         {"A",           cmd_store_ar,           NULL},
 347
 348         {"CR",          cmd_store_cr,           NULL},
 349         {"C",           cmd_store_cr,           NULL},
 350
 351         {"FPCR",        cmd_store_fpcr,         NULL},
 352
 353         {"FPR",         cmd_store_fpr,          NULL},
 354         {"FP",          cmd_store_fpr,          NULL},
 355         {"F",           cmd_store_fpr,          NULL},
 356
 357         {"GPR",         cmd_store_gpr,          NULL},
 358         {"GP",          cmd_store_gpr,          NULL},
 359         {"G",           cmd_store_gpr,          NULL},
 360
 361         {"PSW",         cmd_store_psw,          NULL},
 362
 363         {"STORAGE",     cmd_store_storage,      NULL},
 364         {"STORAG",      cmd_store_storage,      NULL},
 365         {"STORA",       cmd_store_storage,      NULL},
 366         {"STOR",        cmd_store_storage,      NULL},
 367         {"STO",         cmd_store_storage,      NULL},
 368         {"",            NULL,                   NULL},
 369 };