Commit e40e5204 authored by Luc Michel's avatar Luc Michel Committed by Peter Maydell
Browse files

gdbstub: add multiprocess support to vCont packets 



Add the gdb_first_attached_cpu() and gdb_next_attached_cpu() to iterate
over all the CPUs in currently attached processes.

Add the gdb_first_cpu_in_process() and gdb_next_cpu_in_process() to
iterate over CPUs of a given process.

Use them to add multiprocess extension support to vCont packets.

Signed-off-by: default avatarLuc Michel <luc.michel@greensocs.com>
Reviewed-by: default avatarPhilippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: default avatarEdgar E. Iglesias <edgar.iglesias@xilinx.com>
Acked-by: default avatarAlistair Francis <alistair.francis@wdc.com>
Message-id: 20181207090135.7651-6-luc.michel@greensocs.com
[PMM: corrected checkpatch comment style nit]
Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parent 7d8c87da

gdbstub.c

+100 −15
Original line number Diff line number Diff line
@@ -724,6 +724,36 @@ static CPUState *find_cpu(uint32_t thread_id) 
    return NULL;

}



static CPUState *get_first_cpu_in_process(const GDBState *s,

                                          GDBProcess *process)

{

    CPUState *cpu;



    CPU_FOREACH(cpu) {

        if (gdb_get_cpu_pid(s, cpu) == process->pid) {

            return cpu;

        }

    }



    return NULL;

}



static CPUState *gdb_next_cpu_in_process(const GDBState *s, CPUState *cpu)

{

    uint32_t pid = gdb_get_cpu_pid(s, cpu);

    cpu = CPU_NEXT(cpu);



    while (cpu) {

        if (gdb_get_cpu_pid(s, cpu) == pid) {

            break;

        }



        cpu = CPU_NEXT(cpu);

    }



    return cpu;

}



static CPUState *gdb_get_cpu(const GDBState *s, uint32_t pid, uint32_t tid)

{

    GDBProcess *process;
@@ -753,6 +783,35 @@ static CPUState *gdb_get_cpu(const GDBState *s, uint32_t pid, uint32_t tid) 
    return cpu;

}



/* Return the cpu following @cpu, while ignoring unattached processes. */

static CPUState *gdb_next_attached_cpu(const GDBState *s, CPUState *cpu)

{

    cpu = CPU_NEXT(cpu);



    while (cpu) {

        if (gdb_get_cpu_process(s, cpu)->attached) {

            break;

        }



        cpu = CPU_NEXT(cpu);

    }



    return cpu;

}



/* Return the first attached cpu */

static CPUState *gdb_first_attached_cpu(const GDBState *s)

{

    CPUState *cpu = first_cpu;

    GDBProcess *process = gdb_get_cpu_process(s, cpu);



    if (!process->attached) {

        return gdb_next_attached_cpu(s, cpu);

    }



    return cpu;

}



static const char *get_feature_xml(const char *p, const char **newp,

                                   CPUClass *cc)

{
@@ -1091,10 +1150,12 @@ static int is_query_packet(const char *p, const char *query, char separator) 
 */

static int gdb_handle_vcont(GDBState *s, const char *p)

{

    int res, idx, signal = 0;

    int res, signal = 0;

    char cur_action;

    char *newstates;

    unsigned long tmp;

    uint32_t pid, tid;

    GDBProcess *process;

    CPUState *cpu;

#ifdef CONFIG_USER_ONLY

    int max_cpus = 1; /* global variable max_cpus exists only in system mode */
@@ -1137,25 +1198,48 @@ static int gdb_handle_vcont(GDBState *s, const char *p) 
            res = -ENOTSUP;

            goto out;

        }

        /* thread specification. special values: (none), -1 = all; 0 = any */

        if ((p[0] == ':' && p[1] == '-' && p[2] == '1') || (p[0] != ':')) {

            if (*p == ':') {

                p += 3;



        if (*p++ != ':') {

            res = -ENOTSUP;

            goto out;

        }

            for (idx = 0; idx < max_cpus; idx++) {

                if (newstates[idx] == 1) {

                    newstates[idx] = cur_action;



        switch (read_thread_id(p, &p, &pid, &tid)) {

        case GDB_READ_THREAD_ERR:

            res = -EINVAL;

            goto out;



        case GDB_ALL_PROCESSES:

            cpu = gdb_first_attached_cpu(s);

            while (cpu) {

                if (newstates[cpu->cpu_index] == 1) {

                    newstates[cpu->cpu_index] = cur_action;

                }



                cpu = gdb_next_attached_cpu(s, cpu);

            }

        } else if (*p == ':') {

            p++;

            res = qemu_strtoul(p, &p, 16, &tmp);

            if (res) {

            break;



        case GDB_ALL_THREADS:

            process = gdb_get_process(s, pid);



            if (!process->attached) {

                res = -EINVAL;

                goto out;

            }



            /* 0 means any thread, so we pick the first valid CPU */

            cpu = tmp ? find_cpu(tmp) : first_cpu;

            cpu = get_first_cpu_in_process(s, process);

            while (cpu) {

                if (newstates[cpu->cpu_index] == 1) {

                    newstates[cpu->cpu_index] = cur_action;

                }



                cpu = gdb_next_cpu_in_process(s, cpu);

            }

            break;



        case GDB_ONE_THREAD:

            cpu = gdb_get_cpu(s, pid, tid);



            /* invalid CPU/thread specified */

            if (!cpu) {
@@ -1167,6 +1251,7 @@ static int gdb_handle_vcont(GDBState *s, const char *p) 
            if (newstates[cpu->cpu_index] == 1) {

                newstates[cpu->cpu_index] = cur_action;

            }

            break;

        }

    }

    s->signal = signal;