go-delve/delve · error

qMemoryRegionInfo error: %s

Error message

qMemoryRegionInfo error: %s

What it means

This error surfaces when the remote stub explicitly reports a failure for the qMemoryRegionInfo query by including an 'error:<hex-encoded text>' key in its response. Unlike the malformed-packet errors, the packet is well-formed; the target itself rejected the query. Delve decodes the hex error text and propagates it to the caller.

Source

Thrown at pkg/proc/gdbserial/gdbserver_conn.go:1311

			size, err := strconv.ParseUint(string(value), 16, 64)
			if err != nil {
				return nil, fmt.Errorf("malformed qMemoryRegionInfo response packet (size): %v in %s", err, string(resp))
			}
			mri.size = size
		case "permissions":
			mri.permissions = string(value)
		case "name":
			namestr, ok := decodeHexString(value)
			if !ok {
				return nil, fmt.Errorf("malformed qMemoryRegionInfo response packet (name): %s", string(resp))
			}
			mri.name = namestr
		case "error":
			errstr, ok := decodeHexString(value)
			if !ok {
				return nil, fmt.Errorf("malformed qMemoryRegionInfo response packet (error): %s", string(resp))
			}
			return nil, fmt.Errorf("qMemoryRegionInfo error: %s", errstr)
		}
	}

	return mri, nil
}

// exec executes a message to the stub and reads a response.
// The details of the wire protocol are described here:
//
//	https://sourceware.org/gdb/onlinedocs/gdb/Overview.html#Overview
func (conn *gdbConn) exec(cmd []byte, context string) ([]byte, error) {
	if err := conn.send(cmd); err != nil {
		return nil, err
	}
	return conn.recv(cmd, context, false)
}

const hexdigit = "0123456789abcdef"

View on GitHub (pinned to a23773e6c3)

Solutions

1. Read the decoded error text in the message — it states the stub-specific reason
2. Verify the address being queried belongs to a valid mapping in the target process
3. Check stub support for qMemoryRegionInfo (e.g. gdbserver monitor commands) and upgrade it if missing
4. Handle the failure gracefully in the caller (e.g. skip region-dependent features) if the stub will never support it

Example fix

// before: query arbitrary address and crash on error
mri, err := conn.memoryRegionInfo(addr)
// after: treat unsupported stubs as non-fatal
mri, err := conn.memoryRegionInfo(addr)
if err != nil {
    log.Printf("region info unavailable: %v", err)
    return defaultRegion
}

func isRegionInfoUnsupported(err error) bool {
    var target *targetErr
    if errors.As(err, &target) && strings.Contains(target.Error(), "qMemoryRegionInfo error:") {
        return true
    }
    return strings.Contains(err.Error(), "qMemoryRegionInfo error:")
}

mri, err := conn.memoryRegionInfo(addr)
if err != nil {
    var msg string
    if strings.HasPrefix(err.Error(), "qMemoryRegionInfo error:") {
        msg = strings.TrimPrefix(err.Error(), "qMemoryRegionInfo error: ")
        log.Printf("target rejected region query: %s", msg)
        return fallbackRegionInfo(addr) // e.g. /proc/self/maps or conservative default
    }
    return err
}

When it happens

Trigger: Any memory-region-info query via the gdbserial backend where the stub responds with an error key — typically because the queried address is outside any known mapping, or qMemoryRegionInfo is unsupported/unimplemented by the stub.

Common situations: Querying addresses not in the target's memory map, connecting to stubs that advertise partial RSP support (e.g. some OpenOCD/embedded monitors), stripped-down gdbserver implementations lacking qMemoryRegionInfo.

Related errors

• qMemoryRegionInfo response wrapped around the address space
• too many transmit attempts
• malformed qfThreadInfo response
• could not determine executable path: %v
• malformed qMemoryRegionInfo response packet (start): %v in %

AI-assisted analysis of go-delve/delve@a23773e6c3 (2026-08-31). Data as JSON: /api/errors/cf1e99599f590229. Report an issue: GitHub.