rtos: Use 'bool' as return type for detect_rtos()

[openocd.git] / src / rtos / linux.c

diff --git a/src/rtos/linux.c b/src/rtos/linux.c
index 68b2d1d2faec84792bd9ae752b78859856f2a072..3b2a2b0c34b440fb72effcc1ab450213820dd434 100644 (file)
--- a/src/rtos/linux.c
+++ b/src/rtos/linux.c
@@ -14,9 +14,7 @@
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
- *   along with this program; if not, write to the                         *
- *   Free Software Foundation, Inc.,                                       *
- *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #ifdef HAVE_CONFIG_H
@@ -40,7 +38,7 @@
 #define MAX_THREADS 200
 /*  specific task  */
 struct linux_os {
-       char *name;
+       const char *name;
        uint32_t init_task_addr;
        int thread_count;
        int threadid_count;
@@ -107,11 +105,11 @@ static int linux_os_dummy_update(struct rtos *rtos)
        return 0;
 }
 
-static int linux_compute_virt2phys(struct target *target, uint32_t address)
+static int linux_compute_virt2phys(struct target *target, target_addr_t address)
 {
        struct linux_os *linux_os = (struct linux_os *)
                target->rtos->rtos_specific_params;
-       uint32_t pa = 0;
+       target_addr_t pa = 0;
        int retval = target->type->virt2phys(target, address, &pa);
        if (retval != ERROR_OK) {
                LOG_ERROR("Cannot compute linux virt2phys translation");
@@ -140,9 +138,9 @@ static int linux_read_memory(struct target *target,
                return ERROR_FAIL;
        }
 #ifdef PHYS
-       target->type->read_phys_memory(target, pa, size, count, buffer);
+       target_read_phys_memory(target, pa, size, count, buffer);
 #endif
-       target->type->read_memory(target, address, size, count, buffer);
+       target_read_memory(target, address, size, count, buffer);
        return ERROR_OK;
 }
 
@@ -160,7 +158,7 @@ int fill_buffer(struct target *target, uint32_t addr, uint8_t *buffer)
 {
 
        if ((addr & 0xfffffffc) != addr)
-               LOG_INFO("unaligned address %x!!", addr);
+               LOG_INFO("unaligned address %" PRIx32 "!!", addr);
 
        int retval = linux_read_memory(target, addr, 4, 1, buffer);
        return retval;
@@ -217,7 +215,7 @@ static int linux_os_thread_reg_list(struct rtos *rtos,
                if (found == 0) {
                        LOG_ERROR
                        (
-                               "current thread %" PRIx64 ": no target to perform access of core id %x",
+                               "current thread %" PRIx64 ": no target to perform access of core id %" PRIx32,
                                thread_id,
                                next->core_id);
                        return ERROR_FAIL;
@@ -226,7 +224,8 @@ static int linux_os_thread_reg_list(struct rtos *rtos,
                /*LOG_INFO("thread %lx current on core %x",thread_id,
                 * target->coreid);*/
                retval =
-                       target_get_gdb_reg_list(target, &reg_list, &reg_list_size);
+                       target_get_gdb_reg_list(target, &reg_list, &reg_list_size,
+                                       REG_CLASS_GENERAL);
 
                if (retval != ERROR_OK)
                        return retval;
@@ -234,6 +233,8 @@ static int linux_os_thread_reg_list(struct rtos *rtos,
                for (i = 0; i < reg_list_size; i++)
                        reg_packet_size += reg_list[i]->size;
 
+               assert(reg_packet_size > 0);
+
                *hex_reg_list = malloc(DIV_ROUND_UP(reg_packet_size, 8) * 2);
 
                hex_string = *hex_reg_list;
@@ -251,7 +252,7 @@ static int linux_os_thread_reg_list(struct rtos *rtos,
 
        } else {
                struct threads *temp = linux_os->thread_list;
-               *hex_reg_list = (char *)calloc(1, 500 * sizeof(char));
+               *hex_reg_list = calloc(1, 500 * sizeof(char));
                hex_string = *hex_reg_list;
 
                for (i = 0; i < 16; i++)
@@ -308,16 +309,16 @@ static int linux_os_thread_reg_list(struct rtos *rtos,
        return ERROR_OK;
 }
 
-static int linux_os_detect(struct target *target)
+static bool linux_os_detect(struct target *target)
 {
        LOG_INFO("should no be called");
-       return 0;
+       return false;
 }
 
 static int linux_os_smp_init(struct target *target);
 static int linux_os_clean(struct target *target);
 #define INIT_TASK 0
-static char *linux_symbol_list[] = {
+static const char * const linux_symbol_list[] = {
        "init_task",
        NULL
 };
@@ -326,7 +327,7 @@ static int linux_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[])
 {
        unsigned int i;
        *symbol_list = (symbol_table_elem_t *)
-               malloc(sizeof(symbol_table_elem_t) * ARRAY_SIZE(linux_symbol_list));
+               calloc(ARRAY_SIZE(linux_symbol_list), sizeof(symbol_table_elem_t));
 
        for (i = 0; i < ARRAY_SIZE(linux_symbol_list); i++)
                (*symbol_list)[i].symbol_name = linux_symbol_list[i];
@@ -348,7 +349,7 @@ const struct rtos_type Linux_os = {
        .ps_command = linux_ps_command,
 };
 
-static int linux_thread_packet(struct connection *connection, char *packet,
+static int linux_thread_packet(struct connection *connection, char const *packet,
                int packet_size);
 static void linux_identify_current_threads(struct target *target);
 
@@ -496,7 +497,7 @@ int get_current(struct target *target, int create)
                int retval;
 
                if (target_get_gdb_reg_list(head->target, &reg_list,
-                               &reg_list_size) != ERROR_OK) {
+                               &reg_list_size, REG_CLASS_GENERAL) != ERROR_OK) {
                        free(buffer);
                        return ERROR_TARGET_FAILURE;
                }
@@ -530,7 +531,7 @@ int get_current(struct target *target, int create)
                                        LOG_ERROR
                                                ("error in linux current thread update");
 
-                               if (create) {
+                               if (create && ct) {
                                        struct threads *t;
                                        t = calloc(1, sizeof(struct threads));
                                        t->base_addr = ct->TS;
@@ -1114,7 +1115,7 @@ static int linux_task_update(struct target *target, int context)
 }
 
 int linux_gdb_thread_packet(struct target *target,
-       struct connection *connection, char *packet,
+       struct connection *connection, char const *packet,
        int packet_size)
 {
        int retval;
@@ -1133,25 +1134,25 @@ int linux_gdb_thread_packet(struct target *target,
        if (retval != ERROR_OK)
                return ERROR_TARGET_FAILURE;
 
-       char *out_str = (char *)calloc(1, 350 * sizeof(int64_t));
+       char *out_str = calloc(1, 350 * sizeof(int64_t));
        char *tmp_str = out_str;
        tmp_str += sprintf(tmp_str, "m");
        struct threads *temp = linux_os->thread_list;
-       tmp_str += sprintf(tmp_str, "%016" PRIx64, temp->threadid);
-       temp = temp->next;
 
        while (temp != NULL) {
-               tmp_str += sprintf(tmp_str, ",");
                tmp_str += sprintf(tmp_str, "%016" PRIx64, temp->threadid);
                temp = temp->next;
+               if (temp)
+                       tmp_str += sprintf(tmp_str, ",");
        }
 
        gdb_put_packet(connection, out_str, strlen(out_str));
+       free(out_str);
        return ERROR_OK;
 }
 
 int linux_gdb_thread_update(struct target *target,
-       struct connection *connection, char *packet,
+       struct connection *connection, char const *packet,
        int packet_size)
 {
        int found = 0;
@@ -1170,7 +1171,7 @@ int linux_gdb_thread_update(struct target *target,
 
        if (found == 1) {
                /*LOG_INFO("INTO GDB THREAD UPDATE FOUNDING START TASK");*/
-               char *out_strr = (char *)calloc(1, 350 * sizeof(int64_t));
+               char *out_strr = calloc(1, 350 * sizeof(int64_t));
                char *tmp_strr = out_strr;
                tmp_strr += sprintf(tmp_strr, "m");
                /*LOG_INFO("CHAR MALLOC & M DONE");*/
@@ -1198,7 +1199,7 @@ int linux_gdb_thread_update(struct target *target,
 }
 
 int linux_thread_extra_info(struct target *target,
-       struct connection *connection, char *packet,
+       struct connection *connection, char const *packet,
        int packet_size)
 {
        int64_t threadid = 0;
@@ -1212,9 +1213,9 @@ int linux_thread_extra_info(struct target *target,
                if (temp->threadid == threadid) {
                        char *pid = " PID: ";
                        char *pid_current = "*PID: ";
-                       char *name = "NAME: ";
+                       char *name = "Name: ";
                        int str_size = strlen(pid) + strlen(name);
-                       char *tmp_str = (char *)calloc(1, str_size + 50);
+                       char *tmp_str = calloc(1, str_size + 50);
                        char *tmp_str_ptr = tmp_str;
 
                        /*  discriminate current task */
@@ -1224,13 +1225,12 @@ int linux_thread_extra_info(struct target *target,
                        else
                                tmp_str_ptr += sprintf(tmp_str_ptr, "%s", pid);
 
-                       tmp_str_ptr +=
-                               sprintf(tmp_str_ptr, "%d", (int)temp->pid);
-                       tmp_str_ptr += sprintf(tmp_str_ptr, "%s", " | ");
+                       tmp_str_ptr += sprintf(tmp_str_ptr, "%d, ", (int)temp->pid);
                        sprintf(tmp_str_ptr, "%s", name);
                        sprintf(tmp_str_ptr, "%s", temp->name);
-                       char *hex_str = (char *)calloc(1, strlen(tmp_str) * 2 + 1);
-                       int pkt_len = hexify(hex_str, tmp_str, 0, strlen(tmp_str) * 2 + 1);
+                       char *hex_str = calloc(1, strlen(tmp_str) * 2 + 1);
+                       size_t pkt_len = hexify(hex_str, (const uint8_t *)tmp_str,
+                               strlen(tmp_str), strlen(tmp_str) * 2 + 1);
                        gdb_put_packet(connection, hex_str, pkt_len);
                        free(hex_str);
                        free(tmp_str);
@@ -1245,7 +1245,7 @@ int linux_thread_extra_info(struct target *target,
 }
 
 int linux_gdb_T_packet(struct connection *connection,
-       struct target *target, char *packet, int packet_size)
+       struct target *target, char const *packet, int packet_size)
 {
        int64_t threadid;
        struct linux_os *linux_os = (struct linux_os *)
@@ -1306,7 +1306,7 @@ int linux_gdb_T_packet(struct connection *connection,
 }
 
 int linux_gdb_h_packet(struct connection *connection,
-       struct target *target, char *packet, int packet_size)
+       struct target *target, char const *packet, int packet_size)
 {
        struct linux_os *linux_os = (struct linux_os *)
                target->rtos->rtos_specific_params;
@@ -1374,7 +1374,7 @@ int linux_gdb_h_packet(struct connection *connection,
        return ERROR_OK;
 }
 
-static int linux_thread_packet(struct connection *connection, char *packet,
+static int linux_thread_packet(struct connection *connection, char const *packet,
        int packet_size)
 {
        int retval = ERROR_OK;
@@ -1522,7 +1522,7 @@ static int linux_os_create(struct target *target)
        os_linux->threads_needs_update = 0;
        os_linux->threadid_count = 1;
        os_linux->current_threads = NULL;
-       target->rtos->rtos_specific_params = (void *)os_linux;
+       target->rtos->rtos_specific_params = os_linux;
        ct->core_id = target->coreid;
        ct->threadid = -1;
        ct->TS = 0xdeadbeef;
@@ -1569,14 +1569,14 @@ static char *linux_ps_command(struct target *target)
                                if (temp->context)
                                        tmp +=
                                                sprintf(tmp,
-                                                       "%d\t\t%d\t\t%x\t\t%s\n",
-                                                       (int)temp->pid, temp->oncpu,
+                                                       "%" PRId32 "\t\t%" PRId32 "\t\t%" PRIx32 "\t\t%s\n",
+                                                       temp->pid, temp->oncpu,
                                                        temp->asid, temp->name);
                                else
                                        tmp +=
                                                sprintf(tmp,
-                                                       "%d\t\t%d\t\t%x\t\t%s\n",
-                                                       (int)temp->pid, temp->oncpu,
+                                                       "%" PRId32 "\t\t%" PRId32 "\t\t%" PRIx32 "\t\t%s\n",
+                                                       temp->pid, temp->oncpu,
                                                        temp->asid, temp->name);
                        }