_gpu_dxg_r4d_alloc2.nx source

1// _gpu_dxg_r4d_alloc2.nx -- SOVEREIGN-GPU ladder R4d ATTEMPT 2: tune the EXISTINGHEAP standard allocation. 2// flags=0x10000 (standard_allocation, bit16) engaged the path -> host returns 0xC000000D STATUS_INVALID_PARAMETER. 3// Vary heap size / sysmem size (4KB vs 64KB GPU granularity vs 128KB) and priv_drv_data_size (24 vs 0), holding 4// flags=0x10000. ret=0 + alloc handle = a REAL allocation. raw syscalls only. No log writes. license_tier: ORIGINAL 5import "nx_syscalls.nx" 6 7const ENUM2_CODE: i64 = 0xC0104714 8const QAI_CODE: i64 = 0xC0184709 9const OAFL_CODE: i64 = 0xC00C4701 10const CDEV_CODE: i64 = 0xC0404702 11const CALLOC_CODE: i64 = 0xC0484706 12 13func p(s: *u8) -> i64 { var nn: i64=0; while s[nn]!=(0 as u8){nn=nn+1} sys_write(1,s,nn); return 0 } 14func n(v: i64) -> i64 { let bb: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m;sys_write(1,"-" as *u8,1)}; let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=48;k=1}; while m>0{t[k]=(48+(m%10)) as u8;m=m/10;k=k+1}; var i: i64=0; while i<k{bb[i]=t[k-1-i];i=i+1}; sys_write(1,bb,k); return 0 } 15func x(v: i64) -> i64 { p("0x" as *u8); let bb:*u8=sys_mmap(20); var k:i64=0; var m:i64=v; if m==0{bb[0]=48;k=1}; while m>0{ let d:i64=m&15; if d<10{bb[k]=(48+d) as u8}else{bb[k]=(87+d) as u8}; m=(m>>4); k=k+1 } var i:i64=0; let o:*u8=sys_mmap(20); while i<k{o[i]=bb[k-1-i];i=i+1} sys_write(1,o,k); return 0 } 16func rd32(buf: *u8, off: i64) -> i64 { return (buf[off] as i64)|((buf[off+1] as i64)<<8)|((buf[off+2] as i64)<<16)|((buf[off+3] as i64)<<24) } 17func rd64(buf: *u8, off: i64) -> i64 { let q: *i64 = (buf as i64 + off) as *i64; return q[0] } 18func setu32(buf: *u8, off: i64, val: i64) -> i64 { let w: *u8 = (buf as i64 + off) as *u8; w[0]=(val&0xff) as u8; w[1]=((val>>8)&0xff) as u8; w[2]=((val>>16)&0xff) as u8; w[3]=((val>>24)&0xff) as u8; return 0 } 19func setu64(buf: *u8, off: i64, val: i64) -> i64 { let q: *i64 = (buf as i64 + off) as *i64; q[0]=val; return 0 } 20 21func query_type(fd: i64, handle: i64, qtype: i64, psize: i64, outv: *i64) -> i64 { 22 let priv: *u8 = sys_mmap(64); var zz: i64 = 0; while zz < 64 { priv[zz] = 0 as u8; zz = zz + 1 } 23 let req: *u8 = sys_mmap(64); var y: i64 = 0; while y < 64 { req[y] = 0 as u8; y = y + 1 } 24 let h: *i64 = (req as i64 + 0) as *i64; h[0] = (handle & 0xffffffff) | ((qtype & 0xffffffff) << 32) 25 let pd: *i64 = (req as i64 + 8) as *i64; pd[0] = priv as i64 26 let pds: *i64 = (req as i64 + 16) as *i64; pds[0] = psize & 0xffffffff 27 let ret: i64 = sys_ioctl(fd, QAI_CODE, req as i64); outv[0] = rd32(priv, 0); return ret 28} 29func open_from_luid(fd: i64, luid_lo: i64, luid_hi: i64, outh: *i64) -> i64 { 30 let req: *u8 = sys_mmap(64); var y: i64 = 0; while y < 64 { req[y] = 0 as u8; y = y + 1 } 31 let lo: *i64 = (req as i64 + 0) as *i64; lo[0] = (luid_lo & 0xffffffff) | ((luid_hi & 0xffffffff) << 32) 32 let ret: i64 = sys_ioctl(fd, OAFL_CODE, req as i64); outh[0] = rd32(req, 8); return ret 33} 34func create_device(fd: i64, adapter: i64, outd: *i64) -> i64 { 35 let buf: *u8 = sys_mmap(512); var bz: i64 = 0; while bz < 512 { buf[bz] = 0 as u8; bz = bz + 1 } 36 setu32(buf, 0, adapter & 0xffffffff) 37 let ret: i64 = sys_ioctl(fd, CDEV_CODE, buf as i64); outd[0] = rd32(buf, 12); return ret 38} 39func try_alloc(fd: i64, device: i64, psize: i64, heapsize: i64, sysmem: *u8, outa: *i64, outva: *i64) -> i64 { 40 let desc: *u8 = sys_mmap(64); var dz: i64 = 0; while dz < 64 { desc[dz] = 0 as u8; dz = dz + 1 } 41 setu32(desc, 0, 1); setu64(desc, 8, heapsize) // EXISTINGHEAP, size 42 let entry: *u8 = sys_mmap(256); var ez: i64 = 0; while ez < 256 { entry[ez] = 0 as u8; ez = ez + 1 } 43 setu64(entry, 8, sysmem as i64) // sysmem @8 44 let buf: *u8 = sys_mmap(512); var bz: i64 = 0; while bz < 512 { buf[bz] = 0 as u8; bz = bz + 1 } 45 setu32(buf, 0, device & 0xffffffff) 46 setu64(buf, 32, desc as i64); setu32(buf, 40, psize) 47 setu32(buf, 44, 1); setu64(buf, 48, entry as i64) 48 setu32(buf, 56, 0x10000) // flags: standard_allocation 49 let ret: i64 = sys_ioctl(fd, CALLOC_CODE, buf as i64) 50 outa[0] = rd32(entry, 0); outva[0] = rd64(entry, 40); return ret 51} 52 53func main() -> i64 { 54 p("=== R4d ATTEMPT 2: tune EXISTINGHEAP size/alignment (flags=0x10000) ===\n" as *u8) 55 let fd: i64 = sys_openat_rd("/dev/dxg" as *u8) 56 if fd < 0 { p("open(/dev/dxg) failed\n" as *u8); sys_exit(1); return 1 } 57 let ainfo: *u8 = sys_mmap(4096); var z: i64 = 0; while z < 4096 { ainfo[z] = 0 as u8; z = z + 1 } 58 let ereq: *u8 = sys_mmap(64); ereq[0] = 8 as u8; let r8: *i64 = (ereq as i64 + 8) as *i64; r8[0] = ainfo as i64 59 sys_ioctl(fd, ENUM2_CODE, ereq as i64); let nc: i64 = rd32(ereq, 0) 60 let v: *i64 = sys_mmap(16); var disc_lo: i64 = 0; var disc_hi: i64 = 0 61 var ai: i64 = 0 62 while ai < nc { 63 let base: i64 = ai * 20; let eh: i64 = rd32(ainfo, base) 64 let qret: i64 = query_type(fd, eh, 15, 4, v); let t: i64 = v[0] 65 if qret == 0 { if ((t>>4)&1) == 1 { if ((t>>2)&1) == 0 { disc_lo = rd32(ainfo, base+4); disc_hi = rd32(ainfo, base+8) } } } 66 ai = ai + 1 67 } 68 let ah: *i64 = sys_mmap(16); open_from_luid(fd, disc_lo, disc_hi, ah) 69 let dh: *i64 = sys_mmap(16); create_device(fd, ah[0], dh); let device: i64 = dh[0] 70 p(" device=" as *u8); x(device); p("\n (psize, heapsize) -> ret : alloc : gpu_va\n" as *u8) 71 72 // big page-aligned sysmem region (256KB) reused for all sizes (mmap is page-aligned). 73 let sysmem: *u8 = sys_mmap(262144); var sz: i64 = 0; while sz < 262144 { sysmem[sz] = 0 as u8; sz = sz + 1 } 74 let oa: *i64 = sys_mmap(16); let ova: *i64 = sys_mmap(16) 75 76 let ps: *i64 = sys_mmap(64); let hs: *i64 = sys_mmap(64) 77 ps[0]=24; hs[0]=4096 78 ps[1]=24; hs[1]=65536 79 ps[2]=0; hs[2]=65536 80 ps[3]=24; hs[3]=131072 81 ps[4]=0; hs[4]=4096 82 ps[5]= 0 - 1 83 var i: i64 = 0 84 while ps[i] != (0 - 1) { 85 let r: i64 = try_alloc(fd, device, ps[i], hs[i], sysmem, oa, ova) 86 p(" (" as *u8); n(ps[i]); p(", " as *u8); n(hs[i]); p(") -> ret=" as *u8); n(r); p(" : alloc=" as *u8); x(oa[0]); p(" : gpu_va=" as *u8); x(ova[0]) 87 if r == 0 { if oa[0] != 0 { p(" <== REAL ALLOCATION!!" as *u8) } } 88 p("\n" as *u8) 89 i = i + 1 90 } 91 sys_close(fd) 92 p("=== R4d ATTEMPT 2 DONE ===\n" as *u8) 93 return 0 94}