src/target/arm_semihosting.c

   1 /***************************************************************************
   2  *   Copyright (C) 2009 by Marvell Technology Group Ltd.                   *
   3  *   Written by Nicolas Pitre <nico@marvell.com>                           *
   4  *                                                                         *
   5  *   Copyright (C) 2010 by Spencer Oliver                                  *
   6  *   spen@spen-soft.co.uk                                                  *
   7  *                                                                         *
   8  *   This program is free software; you can redistribute it and/or modify  *
   9  *   it under the terms of the GNU General Public License as published by  *
  10  *   the Free Software Foundation; either version 2 of the License, or     *
  11  *   (at your option) any later version.                                   *
  12  *                                                                         *
  13  *   This program is distributed in the hope that it will be useful,       *
  14  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  15  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  16  *   GNU General Public License for more details.                          *
  17  *                                                                         *
  18  *   You should have received a copy of the GNU General Public License     *
  19  *   along with this program; if not, write to the                         *
  20  *   Free Software Foundation, Inc.,                                       *
  21  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  22  ***************************************************************************/
  23
  24 /**
  25  * @file
  26  * Hold ARM semihosting support.
  27  *
  28  * Semihosting enables code running on an ARM target to use the I/O
  29  * facilities on the host computer. The target application must be linked
  30  * against a library that forwards operation requests by using the SVC
  31  * instruction trapped at the Supervisor Call vector by the debugger.
  32  * Details can be found in chapter 8 of DUI0203I_rvct_developer_guide.pdf
  33  * from ARM Ltd.
  34  */
  35
  36 #ifdef HAVE_CONFIG_H
  37 #include "config.h"
  38 #endif
  39
  40 #include "arm.h"
  41 #include "armv4_5.h"
  42 #include "register.h"
  43 #include "arm_semihosting.h"
  44 #include <helper/binarybuffer.h>
  45 #include <helper/log.h>
  46 #include <sys/stat.h>
  47
  48 static int open_modeflags[12] = {
  49         O_RDONLY,
  50         O_RDONLY | O_BINARY,
  51         O_RDWR,
  52         O_RDWR | O_BINARY,
  53         O_WRONLY | O_CREAT | O_TRUNC,
  54         O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
  55         O_RDWR | O_CREAT | O_TRUNC,
  56         O_RDWR | O_CREAT | O_TRUNC | O_BINARY,
  57         O_WRONLY | O_CREAT | O_APPEND,
  58         O_WRONLY | O_CREAT | O_APPEND | O_BINARY,
  59         O_RDWR | O_CREAT | O_APPEND,
  60         O_RDWR | O_CREAT | O_APPEND | O_BINARY
  61 };
  62
  63 static int do_semihosting(struct target *target)
  64 {
  65         struct arm *armv4_5 = target_to_arm(target);
  66         uint32_t r0 = buf_get_u32(armv4_5->core_cache->reg_list[0].value, 0, 32);
  67         uint32_t r1 = buf_get_u32(armv4_5->core_cache->reg_list[1].value, 0, 32);
  68         uint32_t lr = buf_get_u32(ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, ARM_MODE_SVC, 14).value, 0, 32);
  69         uint32_t spsr = buf_get_u32(armv4_5->spsr->value, 0, 32);;
  70         uint8_t params[16];
  71         int retval, result;
  72
  73         /*
  74          * TODO: lots of security issues are not considered yet, such as:
  75          * - no validation on target provided file descriptors
  76          * - no safety checks on opened/deleted/renamed file paths
  77          * Beware the target app you use this support with.
  78          *
  79          * TODO: explore mapping requests to GDB's "File-I/O Remote
  80          * Protocol Extension" ... when GDB is active.
  81          */
  82         switch (r0) {
  83         case 0x01:      /* SYS_OPEN */
  84                 retval = target_read_memory(target, r1, 4, 3, params);
  85                 if (retval != ERROR_OK)
  86                         return retval;
  87                 else {
  88                         uint32_t a = target_buffer_get_u32(target, params+0);
  89                         uint32_t m = target_buffer_get_u32(target, params+4);
  90                         uint32_t l = target_buffer_get_u32(target, params+8);
  91                         if (l <= 255 && m <= 11) {
  92                                 uint8_t fn[256];
  93                                 retval = target_read_memory(target, a, 1, l, fn);
  94                                 if (retval != ERROR_OK)
  95                                         return retval;
  96                                 fn[l] = 0;
  97                                 if (strcmp((char *)fn, ":tt") == 0) {
  98                                         if (m < 4)
  99                                                 result = dup(STDIN_FILENO);
 100                                         else
 101                                                 result = dup(STDOUT_FILENO);
 102                                 } else {
 103                                         /* cygwin requires the permission setting
 104                                          * otherwise it will fail to reopen a previously
 105                                          * written file */
 106                                         result = open((char *)fn, open_modeflags[m], 0644);
 107                                 }
 108                                 armv4_5->semihosting_errno =  errno;
 109                         } else {
 110                                 result = -1;
 111                                 armv4_5->semihosting_errno = EINVAL;
 112                         }
 113                 }
 114                 break;
 115
 116         case 0x02:      /* SYS_CLOSE */
 117                 retval = target_read_memory(target, r1, 4, 1, params);
 118                 if (retval != ERROR_OK)
 119                         return retval;
 120                 else {
 121                         int fd = target_buffer_get_u32(target, params+0);
 122                         result = close(fd);
 123                         armv4_5->semihosting_errno = errno;
 124                 }
 125                 break;
 126
 127         case 0x03:      /* SYS_WRITEC */
 128                 {
 129                         unsigned char c;
 130                         retval = target_read_memory(target, r1, 1, 1, &c);
 131                         if (retval != ERROR_OK)
 132                                 return retval;
 133                         putchar(c);
 134                         result = 0;
 135                 }
 136                 break;
 137
 138         case 0x04:      /* SYS_WRITE0 */
 139                 do {
 140                         unsigned char c;
 141                         retval = target_read_memory(target, r1, 1, 1, &c);
 142                         if (retval != ERROR_OK)
 143                                 return retval;
 144                         if (!c)
 145                                 break;
 146                         putchar(c);
 147                 } while (1);
 148                 result = 0;
 149                 break;
 150
 151         case 0x05:      /* SYS_WRITE */
 152                 retval = target_read_memory(target, r1, 4, 3, params);
 153                 if (retval != ERROR_OK)
 154                         return retval;
 155                 else {
 156                         int fd = target_buffer_get_u32(target, params+0);
 157                         uint32_t a = target_buffer_get_u32(target, params+4);
 158                         size_t l = target_buffer_get_u32(target, params+8);
 159                         uint8_t *buf = malloc(l);
 160                         if (!buf) {
 161                                 result = -1;
 162                                 armv4_5->semihosting_errno = ENOMEM;
 163                         } else {
 164                                 retval = target_read_buffer(target, a, l, buf);
 165                                 if (retval != ERROR_OK) {
 166                                         free(buf);
 167                                         return retval;
 168                                 }
 169                                 result = write(fd, buf, l);
 170                                 armv4_5->semihosting_errno = errno;
 171                                 if (result >= 0)
 172                                         result = l - result;
 173                                 free(buf);
 174                         }
 175                 }
 176                 break;
 177
 178         case 0x06:      /* SYS_READ */
 179                 retval = target_read_memory(target, r1, 4, 3, params);
 180                 if (retval != ERROR_OK)
 181                         return retval;
 182                 else {
 183                         int fd = target_buffer_get_u32(target, params+0);
 184                         uint32_t a = target_buffer_get_u32(target, params+4);
 185                         ssize_t l = target_buffer_get_u32(target, params+8);
 186                         uint8_t *buf = malloc(l);
 187                         if (!buf) {
 188                                 result = -1;
 189                                 armv4_5->semihosting_errno = ENOMEM;
 190                         } else {
 191                                 result = read(fd, buf, l);
 192                                 armv4_5->semihosting_errno = errno;
 193                                 if (result > 0) {
 194                                         retval = target_write_buffer(target, a, result, buf);
 195                                         if (retval != ERROR_OK) {
 196                                                 free(buf);
 197                                                 return retval;
 198                                         }
 199                                         result = l - result;
 200                                 }
 201                                 free(buf);
 202                         }
 203                 }
 204                 break;
 205
 206         case 0x07:      /* SYS_READC */
 207                 result = getchar();
 208                 break;
 209
 210         case 0x08:      /* SYS_ISERROR */
 211                 retval = target_read_memory(target, r1, 4, 1, params);
 212                 if (retval != ERROR_OK)
 213                         return retval;
 214                 result = (target_buffer_get_u32(target, params+0) != 0);
 215                 break;
 216
 217         case 0x09:      /* SYS_ISTTY */
 218                 retval = target_read_memory(target, r1, 4, 1, params);
 219                 if (retval != ERROR_OK)
 220                         return retval;
 221                 result = isatty(target_buffer_get_u32(target, params+0));
 222                 break;
 223
 224         case 0x0a:      /* SYS_SEEK */
 225                 retval = target_read_memory(target, r1, 4, 2, params);
 226                 if (retval != ERROR_OK)
 227                         return retval;
 228                 else {
 229                         int fd = target_buffer_get_u32(target, params+0);
 230                         off_t pos = target_buffer_get_u32(target, params+4);
 231                         result = lseek(fd, pos, SEEK_SET);
 232                         armv4_5->semihosting_errno = errno;
 233                         if (result == pos)
 234                                 result = 0;
 235                 }
 236                 break;
 237
 238         case 0x0c:      /* SYS_FLEN */
 239                 retval = target_read_memory(target, r1, 4, 1, params);
 240                 if (retval != ERROR_OK)
 241                         return retval;
 242                 else {
 243                         int fd = target_buffer_get_u32(target, params+0);
 244                         struct stat buf;
 245                         result = fstat(fd, &buf);
 246                         if (result == -1) {
 247                                 armv4_5->semihosting_errno = errno;
 248                                 result = -1;
 249                                 break;
 250                         }
 251                         result = buf.st_size;
 252                 }
 253                 break;
 254
 255         case 0x0e:      /* SYS_REMOVE */
 256                 retval = target_read_memory(target, r1, 4, 2, params);
 257                 if (retval != ERROR_OK)
 258                         return retval;
 259                 else {
 260                         uint32_t a = target_buffer_get_u32(target, params+0);
 261                         uint32_t l = target_buffer_get_u32(target, params+4);
 262                         if (l <= 255) {
 263                                 uint8_t fn[256];
 264                                 retval = target_read_memory(target, a, 1, l, fn);
 265                                 if (retval != ERROR_OK)
 266                                         return retval;
 267                                 fn[l] = 0;
 268                                 result = remove((char *)fn);
 269                                 armv4_5->semihosting_errno =  errno;
 270                         } else {
 271                                 result = -1;
 272                                 armv4_5->semihosting_errno = EINVAL;
 273                         }
 274                 }
 275                 break;
 276
 277         case 0x0f:      /* SYS_RENAME */
 278                 retval = target_read_memory(target, r1, 4, 4, params);
 279                 if (retval != ERROR_OK)
 280                         return retval;
 281                 else {
 282                         uint32_t a1 = target_buffer_get_u32(target, params+0);
 283                         uint32_t l1 = target_buffer_get_u32(target, params+4);
 284                         uint32_t a2 = target_buffer_get_u32(target, params+8);
 285                         uint32_t l2 = target_buffer_get_u32(target, params+12);
 286                         if (l1 <= 255 && l2 <= 255) {
 287                                 uint8_t fn1[256], fn2[256];
 288                                 retval = target_read_memory(target, a1, 1, l1, fn1);
 289                                 if (retval != ERROR_OK)
 290                                         return retval;
 291                                 retval = target_read_memory(target, a2, 1, l2, fn2);
 292                                 if (retval != ERROR_OK)
 293                                         return retval;
 294                                 fn1[l1] = 0;
 295                                 fn2[l2] = 0;
 296                                 result = rename((char *)fn1, (char *)fn2);
 297                                 armv4_5->semihosting_errno =  errno;
 298                         } else {
 299                                 result = -1;
 300                                 armv4_5->semihosting_errno = EINVAL;
 301                         }
 302                 }
 303                 break;
 304
 305         case 0x11:      /* SYS_TIME */
 306                 result = time(NULL);
 307                 break;
 308
 309         case 0x13:      /* SYS_ERRNO */
 310                 result = armv4_5->semihosting_errno;
 311                 break;
 312
 313         case 0x15:      /* SYS_GET_CMDLINE */
 314                 retval = target_read_memory(target, r1, 4, 2, params);
 315                 if (retval != ERROR_OK)
 316                         return retval;
 317                 else {
 318                         uint32_t a = target_buffer_get_u32(target, params+0);
 319                         uint32_t l = target_buffer_get_u32(target, params+4);
 320                         char *arg = "foobar";
 321                         uint32_t s = strlen(arg) + 1;
 322                         if (l < s)
 323                                 result = -1;
 324                         else {
 325                                 retval = target_write_buffer(target, a, s, (void*)arg);
 326                                 if (retval != ERROR_OK)
 327                                         return retval;
 328                                 result = 0;
 329                         }
 330                 }
 331                 break;
 332
 333         case 0x16:      /* SYS_HEAPINFO */
 334                 retval = target_read_memory(target, r1, 4, 1, params);
 335                 if (retval != ERROR_OK)
 336                         return retval;
 337                 else {
 338                         uint32_t a = target_buffer_get_u32(target, params+0);
 339                         /* tell the remote we have no idea */
 340                         memset(params, 0, 4*4);
 341                         retval = target_write_memory(target, a, 4, 4, params);
 342                         if (retval != ERROR_OK)
 343                                 return retval;
 344                         result = 0;
 345                 }
 346                 break;
 347
 348         case 0x18:      /* angel_SWIreason_ReportException */
 349                 switch (r1) {
 350                 case 0x20026:   /* ADP_Stopped_ApplicationExit */
 351                         fprintf(stderr, "semihosting: *** application exited ***\n");
 352                         break;
 353                 case 0x20000:   /* ADP_Stopped_BranchThroughZero */
 354                 case 0x20001:   /* ADP_Stopped_UndefinedInstr */
 355                 case 0x20002:   /* ADP_Stopped_SoftwareInterrupt */
 356                 case 0x20003:   /* ADP_Stopped_PrefetchAbort */
 357                 case 0x20004:   /* ADP_Stopped_DataAbort */
 358                 case 0x20005:   /* ADP_Stopped_AddressException */
 359                 case 0x20006:   /* ADP_Stopped_IRQ */
 360                 case 0x20007:   /* ADP_Stopped_FIQ */
 361                 case 0x20020:   /* ADP_Stopped_BreakPoint */
 362                 case 0x20021:   /* ADP_Stopped_WatchPoint */
 363                 case 0x20022:   /* ADP_Stopped_StepComplete */
 364                 case 0x20023:   /* ADP_Stopped_RunTimeErrorUnknown */
 365                 case 0x20024:   /* ADP_Stopped_InternalError */
 366                 case 0x20025:   /* ADP_Stopped_UserInterruption */
 367                 case 0x20027:   /* ADP_Stopped_StackOverflow */
 368                 case 0x20028:   /* ADP_Stopped_DivisionByZero */
 369                 case 0x20029:   /* ADP_Stopped_OSSpecific */
 370                 default:
 371                         fprintf(stderr, "semihosting: exception %#x\n",
 372                                         (unsigned) r1);
 373                 }
 374                 return target_call_event_callbacks(target, TARGET_EVENT_HALTED);
 375
 376         case 0x0d:      /* SYS_TMPNAM */
 377         case 0x10:      /* SYS_CLOCK */
 378         case 0x12:      /* SYS_SYSTEM */
 379         case 0x17:      /* angel_SWIreason_EnterSVC */
 380         case 0x30:      /* SYS_ELAPSED */
 381         case 0x31:      /* SYS_TICKFREQ */
 382         default:
 383                 fprintf(stderr, "semihosting: unsupported call %#x\n",
 384                                 (unsigned) r0);
 385                 result = -1;
 386                 armv4_5->semihosting_errno = ENOTSUP;
 387         }
 388
 389         /* resume execution to the original mode */
 390
 391         /* return value in R0 */
 392         buf_set_u32(armv4_5->core_cache->reg_list[0].value, 0, 32, result);
 393         armv4_5->core_cache->reg_list[0].dirty = 1;
 394
 395         /* LR --> PC */
 396         buf_set_u32(armv4_5->core_cache->reg_list[15].value, 0, 32, lr);
 397         armv4_5->core_cache->reg_list[15].dirty = 1;
 398
 399         /* saved PSR --> current PSR */
 400         buf_set_u32(armv4_5->cpsr->value, 0, 32, spsr);
 401         armv4_5->cpsr->dirty = 1;
 402         armv4_5->core_mode = spsr & 0x1f;
 403         if (spsr & 0x20)
 404                 armv4_5->core_state = ARM_STATE_THUMB;
 405
 406         return target_resume(target, 1, 0, 0, 0);
 407 }
 408
 409 /**
 410  * Checks for and processes an ARM semihosting request.  This is meant
 411  * to be called when the target is stopped due to a debug mode entry.
 412  * If the value 0 is returned then there was nothing to process. A non-zero
 413  * return value signifies that a request was processed and the target resumed,
 414  * or an error was encountered, in which case the caller must return
 415  * immediately.
 416  *
 417  * @param target Pointer to the ARM target to process.  This target must
 418  *      not represent an ARMv6-M or ARMv7-M processor.
 419  * @param retval Pointer to a location where the return code will be stored
 420  * @return non-zero value if a request was processed or an error encountered
 421  */
 422 int arm_semihosting(struct target *target, int *retval)
 423 {
 424         struct arm *arm = target_to_arm(target);
 425         uint32_t pc, lr, spsr;
 426         struct reg *r;
 427
 428         if (!arm->is_semihosting || arm->core_mode != ARM_MODE_SVC)
 429                 return 0;
 430
 431         /* Check for PC == 0x00000008 or 0xffff0008: Supervisor Call vector. */
 432         r = arm->core_cache->reg_list + 15;
 433         pc = buf_get_u32(r->value, 0, 32);
 434         if (pc != 0x00000008 && pc != 0xffff0008)
 435                 return 0;
 436
 437         r = arm_reg_current(arm, 14);
 438         lr = buf_get_u32(r->value, 0, 32);
 439
 440         /* Core-specific code should make sure SPSR is retrieved
 441          * when the above checks pass...
 442          */
 443         if (!arm->spsr->valid) {
 444                 LOG_ERROR("SPSR not valid!");
 445                 *retval = ERROR_FAIL;
 446                 return 1;
 447         }
 448
 449         spsr = buf_get_u32(arm->spsr->value, 0, 32);
 450
 451         /* check instruction that triggered this trap */
 452         if (spsr & (1 << 5)) {
 453                 /* was in Thumb (or ThumbEE) mode */
 454                 uint8_t insn_buf[2];
 455                 uint16_t insn;
 456
 457                 *retval = target_read_memory(target, lr-2, 2, 1, insn_buf);
 458                 if (*retval != ERROR_OK)
 459                         return 1;
 460                 insn = target_buffer_get_u16(target, insn_buf);
 461
 462                 /* SVC 0xab */
 463                 if (insn != 0xDFAB)
 464                         return 0;
 465         } else if (spsr & (1 << 24)) {
 466                 /* was in Jazelle mode */
 467                 return 0;
 468         } else {
 469                 /* was in ARM mode */
 470                 uint8_t insn_buf[4];
 471                 uint32_t insn;
 472
 473                 *retval = target_read_memory(target, lr-4, 4, 1, insn_buf);
 474                 if (*retval != ERROR_OK)
 475                         return 1;
 476                 insn = target_buffer_get_u32(target, insn_buf);
 477
 478                 /* SVC 0x123456 */
 479                 if (insn != 0xEF123456)
 480                         return 0;
 481         }
 482
 483         *retval = do_semihosting(target);
 484         return 1;
 485 }