Page MenuHomeFreeBSD
Differential D47964

cgem: Cleanup detaching of child miibus device
ClosedPublic
Actions

Authored by jhb on Dec 6 2024, 10:31 PM.
Tags
None
Referenced Files
Unknown Object (File)
Tue, Apr 8, 10:28 AM
Unknown Object (File)
Sun, Mar 30, 10:05 PM
Unknown Object (File)
Mar 10 2025, 3:06 PM
Unknown Object (File)
Feb 20 2025, 4:12 AM
Unknown Object (File)
Feb 7 2025, 4:22 AM
Unknown Object (File)
Feb 6 2025, 3:24 AM
Unknown Object (File)
Dec 26 2024, 3:57 AM
Unknown Object (File)
Dec 25 2024, 4:46 PM
View All 11 Files
Subscribers
None

Details

Reviewers
imp
Commits
rGfaf0bf43df0c: cgem: Cleanup detaching of child miibus device
Summary

Move bus_generic_detach earlier in place of the existing
device_delete_child.

Diff Detail

Repository
rG FreeBSD src repository
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

jhb requested review of this revision.Dec 6 2024, 10:31 PM
jhb created this revision.
Harbormaster completed remote builds in B61005: Diff 147642.Dec 6 2024, 10:31 PM
jhb added a parent revision: D47963: cpsw: Remove duplicate call to bus_generic_detach.Dec 6 2024, 10:31 PM
jhb added a child revision: D47965: csa/emu10kx: Simplify deleting child devices.
This revision was not accepted when it landed; it landed in state Needs Review.Jan 2 2025, 6:29 PM
Closed by commit rGfaf0bf43df0c: cgem: Cleanup detaching of child miibus device (authored by jhb). · Explain Why
This revision was automatically updated to reflect the committed changes.
jhb added a commit: rGfaf0bf43df0c: cgem: Cleanup detaching of child miibus device.

Revision Contents
Changeset List

PathSize
sys/
dev/
cadence/
7 lines

Diff 148688

View Options

sys/dev/cadence/if_cgem.c

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Lines
#define LINUX_PTRACE_SYSCALL_INFO_ENTRY 1 #define LINUX_PTRACE_SYSCALL_INFO_ENTRY 1
#define LINUX_PTRACE_SYSCALL_INFO_EXIT 2 #define LINUX_PTRACE_SYSCALL_INFO_EXIT 2
#define LINUX_PTRACE_PEEKUSER_ORIG_RAX 120 #define LINUX_PTRACE_PEEKUSER_ORIG_RAX 120
#define LINUX_PTRACE_PEEKUSER_RIP 128 #define LINUX_PTRACE_PEEKUSER_RIP 128
#define LINUX_PTRACE_PEEKUSER_CS 136 #define LINUX_PTRACE_PEEKUSER_CS 136
#define LINUX_PTRACE_PEEKUSER_DS 184 #define LINUX_PTRACE_PEEKUSER_DS 184
#define LINUX_ARCH_AMD64 0xc000003e
#define LINUX_ARCH_AARCH64 0xc00000b7
static int static int
map_signum(int lsig, int *bsigp) map_signum(int lsig, int *bsigp)
{ {
int bsig; int bsig;
if (lsig == 0) { if (lsig == 0) {
*bsigp = 0; *bsigp = 0;
return (0); return (0);
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lineslinux_ptrace_status(struct thread *td, pid_t pid, int status)
if ((pem->ptrace_flags & LINUX_PTRACE_O_TRACEEXIT) && if ((pem->ptrace_flags & LINUX_PTRACE_O_TRACEEXIT) &&
lwpinfo.pl_flags & PL_FLAG_EXITED) lwpinfo.pl_flags & PL_FLAG_EXITED)
status |= (LINUX_SIGTRAP | LINUX_PTRACE_EVENT_EXIT << 8) << 8; status |= (LINUX_SIGTRAP | LINUX_PTRACE_EVENT_EXIT << 8) << 8;
LINUX_PEM_SUNLOCK(pem); LINUX_PEM_SUNLOCK(pem);
return (status); return (status);
} }
struct syscall_info {
uint8_t op;
uint32_t arch;
uint64_t instruction_pointer;
uint64_t stack_pointer;
union {
struct {
uint64_t nr;
uint64_t args[6];
} entry;
struct {
int64_t rval;
uint8_t is_error;
} exit;
struct {
uint64_t nr;
uint64_t args[6];
uint32_t ret_data;
} seccomp;
};
};
static int static int
linux_ptrace_peek(struct thread *td, pid_t pid, void *addr, void *data) linux_ptrace_peek(struct thread *td, pid_t pid, void *addr, void *data)
{ {
int error; int error;
error = kern_ptrace(td, PT_READ_I, pid, addr, 0); error = kern_ptrace(td, PT_READ_I, pid, addr, 0);
if (error == 0) if (error == 0)
error = copyout(td->td_retval, data, sizeof(l_int)); error = copyout(td->td_retval, data, sizeof(l_int));
▲ Show 20 Lines • Show All 138 Lines • ▼ Show 20 Lineslinux_ptrace_getsiginfo(struct thread *td, pid_t pid, l_ulong data)
return (error); return (error);
} }
static int static int
linux_ptrace_getregs(struct thread *td, pid_t pid, void *data) linux_ptrace_getregs(struct thread *td, pid_t pid, void *data)
{ {
struct reg b_reg; struct reg b_reg;
struct linux_pt_regset l_regset; struct linux_pt_regset l_regset;
#ifdef __amd64__
struct ptrace_lwpinfo lwpinfo;
struct pcb *pcb;
#endif
int error; int error;
error = kern_ptrace(td, PT_GETREGS, pid, &b_reg, 0); error = kern_ptrace(td, PT_GETREGS, pid, &b_reg, 0);
if (error != 0) if (error != 0)
return (error); return (error);
bsd_to_linux_regset(&b_reg, &l_regset); bsd_to_linux_regset(&b_reg, &l_regset);
error = linux_ptrace_getregs_machdep(td, pid, &l_regset);
#ifdef __amd64__ if (error != 0)
pcb = td->td_pcb;
if (td == curthread)
update_pcb_bases(pcb);
l_regset.fs_base = pcb->pcb_fsbase;
l_regset.gs_base = pcb->pcb_gsbase;
error = kern_ptrace(td, PT_LWPINFO, pid, &lwpinfo, sizeof(lwpinfo));
if (error != 0) {
linux_msg(td, "PT_LWPINFO failed with error %d", error);
return (error); return (error);
}
if (lwpinfo.pl_flags & PL_FLAG_SCE) {
/*
* Undo the mangling done in exception.S:fast_syscall_common().
*/
l_regset.r10 = l_regset.rcx;
}
if (lwpinfo.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX)) {
/*
* In Linux, the syscall number - passed to the syscall
* as rax - is preserved in orig_rax; rax gets overwritten
* with syscall return value.
*/
l_regset.orig_rax = lwpinfo.pl_syscall_code;
}
#endif
error = copyout(&l_regset, (void *)data, sizeof(l_regset)); error = copyout(&l_regset, (void *)data, sizeof(l_regset));
return (error); return (error);
} }
static int static int
linux_ptrace_setregs(struct thread *td, pid_t pid, void *data) linux_ptrace_setregs(struct thread *td, pid_t pid, void *data)
{ {
Show All 10 Lines
} }
static int static int
linux_ptrace_getregset_prstatus(struct thread *td, pid_t pid, l_ulong data) linux_ptrace_getregset_prstatus(struct thread *td, pid_t pid, l_ulong data)
{ {
struct reg b_reg; struct reg b_reg;
struct linux_pt_regset l_regset; struct linux_pt_regset l_regset;
struct iovec iov; struct iovec iov;
#ifdef __amd64__
struct ptrace_lwpinfo lwpinfo;
struct pcb *pcb;
#endif
size_t len; size_t len;
int error; int error;
error = copyin((const void *)data, &iov, sizeof(iov)); error = copyin((const void *)data, &iov, sizeof(iov));
if (error != 0) { if (error != 0) {
linux_msg(td, "copyin error %d", error); linux_msg(td, "copyin error %d", error);
return (error); return (error);
} }
error = kern_ptrace(td, PT_GETREGS, pid, &b_reg, 0); error = kern_ptrace(td, PT_GETREGS, pid, &b_reg, 0);
if (error != 0) if (error != 0)
return (error); return (error);
bsd_to_linux_regset(&b_reg, &l_regset); bsd_to_linux_regset(&b_reg, &l_regset);
error = linux_ptrace_getregs_machdep(td, pid, &l_regset);
#ifdef __amd64__ if (error != 0)
pcb = td->td_pcb;
if (td == curthread)
update_pcb_bases(pcb);
l_regset.fs_base = pcb->pcb_fsbase;
l_regset.gs_base = pcb->pcb_gsbase;
error = kern_ptrace(td, PT_LWPINFO, pid, &lwpinfo, sizeof(lwpinfo));
if (error != 0) {
linux_msg(td, "PT_LWPINFO failed with error %d", error);
return (error); return (error);
}
if (lwpinfo.pl_flags & PL_FLAG_SCE) {
/*
* Undo the mangling done in exception.S:fast_syscall_common().
*/
l_regset.r10 = l_regset.rcx;
}
if (lwpinfo.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX)) {
/*
* In Linux, the syscall number - passed to the syscall
* as rax - is preserved in orig_rax; rax gets overwritten
* with syscall return value.
*/
l_regset.orig_rax = lwpinfo.pl_syscall_code;
}
#endif
len = MIN(iov.iov_len, sizeof(l_regset)); len = MIN(iov.iov_len, sizeof(l_regset));
error = copyout(&l_regset, (void *)iov.iov_base, len); error = copyout(&l_regset, (void *)iov.iov_base, len);
if (error != 0) { if (error != 0) {
linux_msg(td, "copyout error %d", error); linux_msg(td, "copyout error %d", error);
return (error); return (error);
} }
iov.iov_len = len; iov.iov_len = len;
▲ Show 20 Lines • Show All 106 Lines • ▼ Show 20 Lineslinux_ptrace_get_syscall_info(struct thread *td, pid_t pid,
} else { } else {
si.op = LINUX_PTRACE_SYSCALL_INFO_NONE; si.op = LINUX_PTRACE_SYSCALL_INFO_NONE;
} }
error = kern_ptrace(td, PT_GETREGS, pid, &b_reg, 0); error = kern_ptrace(td, PT_GETREGS, pid, &b_reg, 0);
if (error != 0) if (error != 0)
return (error); return (error);
#if defined(__amd64__) linux_ptrace_get_syscall_info_machdep(&b_reg, &si);
si.arch = LINUX_ARCH_AMD64;
si.instruction_pointer = b_reg.r_rip;
si.stack_pointer = b_reg.r_rsp;
#elif defined(__aarch64__)
si.arch = LINUX_ARCH_AARCH64;
si.instruction_pointer = b_reg.lr;
si.stack_pointer = b_reg.sp;
#else
#error "unknown architecture"
#endif
len = MIN(len, sizeof(si)); len = MIN(len, sizeof(si));
error = copyout(&si, (void *)data, len); error = copyout(&si, (void *)data, len);
if (error == 0) if (error == 0)
td->td_retval[0] = sizeof(si); td->td_retval[0] = sizeof(si);
return (error); return (error);
} }
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines