chore(explorer): remove [explorer] debug output

Drop startup/input/frame tracing from the desktop shell and window server, including the one-shot diagnostic counters.
2026-10-27 17:54:06 +08:00
1 parent 976b8307f9
commit 93a4f5bdcb
@@ -6,15 +6,6 @@ import vpsdk.syscall as syscall
 import vpsdk.vpui as vpui    # 复用它的 8x16 点阵字体表
 from stdint import *
 import string
-import viperlib
-
-
-# 【诊断·临时】首个鼠标包已收到的标记（0 = 未收到）
-_mouse_logged: int = 0
-# 首次读到键盘字节时打一次（区分"内核没数据"与"事件没送达 app"）
-_kbd_logged: int = 0
-# 【诊断·临时】累计收到的 DESK_REQ_FLUSH 次数（=0 说明 app 从没请求过合成）
-_flush_cnt: int = 0


 # ============================================================================
@@ -375,7 +366,6 @@ class DeskServer:
                                       uint64(syscall.MAP_PRIVATE | syscall.MAP_ANONYMOUS),
                                       syscall.MMAP_FD_ANON, 0)
        if back_va == 0:
-            devfs.serial_puts("[explorer] back buffer alloc FAILED\n")
            self.back = self.fb          # 退化：直写 framebuffer，保留原行为
        else:
            self.back = uint32*(back_va)
@@ -1660,25 +1650,12 @@ class DeskServer:

    # ---------------- 请求处理 ----------------
    def handle_request(self, m: desk.DeskMsg):
-        global _flush_cnt
        if m.type == uint32(desk.DESK_REQ_CREATE):
            # pid 随请求携带（窗口还没诞生），标题内联在消息里
-            _sb: [96]char
-            viperlib.snprintf(&_sb, 96, "[explorer] create style=%d w=%d h=%d\n",
-                              int(m.style), m.c, m.d)
-            devfs.serial_puts(&_sb)
            nw: int = self.alloc_window(m.pid, m.a, m.b, m.c, m.d, int(m.style))
            if nw >= 0:
                ns: desk.WinSlot* = self.slot(nw)
                string.memcpy(&ns.title, &m.title, uint64(desk.DESK_TITLE_MAX))
-                # 【临时诊断】分配成功后立刻回读槽位：坐标/尺寸/缓冲偏移是否真的落进去了。
-                _sb2: [160]char
-                viperlib.snprintf(&_sb2, 160, "[explorer] slot%d x=%d y=%d w=%d h=%d off=%u\n",
-                                  nw, ns.ux, ns.uy, ns.w, ns.h, ns.fb_off)
-                devfs.serial_puts(&_sb2)
-            else:
-                # 【临时诊断】建窗失败（多半是 arena 分配不到）会让 app 拿到 win_id=-1
-                devfs.serial_puts("[explorer] alloc_window FAILED\n")
            self.mark_all_windows()
            self.mark_titles()
            self.push_event_pid(m.pid, nw, uint32(desk.DESK_EVT_CREATED), nw, 0, 0, 0)
@@ -1711,12 +1688,6 @@ class DeskServer:
                if self.hit_test(self.cx, self.cy) == win:
                    self._mark_cursor_band()
        elif ty == uint32(desk.DESK_REQ_FLUSH):
-            # 【临时诊断】首条 FLUSH：证明 app 的"请合成"真的到达了合成器
-            if _flush_cnt == 0:
-                _fb1: [128]char
-                viperlib.snprintf(&_fb1, 128, "[explorer] first FLUSH win=%d uy=%d h=%d\n", win, s.uy, s.h)
-                devfs.serial_puts(&_fb1)
-            _flush_cnt += 1
            # 最小化窗口仍在后台绘制/FLUSH：不要置脏，否则合成器每帧都要重画背景。
            if s.minimized == 0:
                self.mark(s.uy, s.h)
@@ -1793,7 +1764,6 @@ class DeskServer:
        return sent

    def poll_input(self):
-        global _mouse_logged, _kbd_logged
        # --- 键盘：设备侧已给出 ASCII，逐字符投给焦点窗口（无焦点/失效则顶层窗口）---
        # 单轮预算内的投递 + 一次补读：洪流时一轮只推进最多 KB_DELIVER_MAX 字节，
        # 其余留在 kb_pend，保证请求/输入/渲染仍能每轮推进，不会被一次洪流拖死。
@@ -1802,12 +1772,6 @@ class DeskServer:
            kb: [16]char
            kn: int = fs.read(self.kfd, &kb, uint32(16))
            if kn > 0:
-                # 【诊断·临时】首个键盘字节：证明 内核 → devfs → explorer 这段是通的
-                if _kbd_logged == 0:
-                    _kbd_logged = 1
-                    _kb: [96]char
-                    viperlib.snprintf(&_kb, 96, "[explorer] kbd n=%d ch=%d\n", kn, int(kb[0]))
-                    devfs.serial_puts(&_kb)
                if kn > 16: kn = 16
                for i in range(kn):
                    self.kb_pend[i] = kb[i]
@@ -1820,12 +1784,6 @@ class DeskServer:
        mp: [16]uint8
        mn: int = fs.read(self.mfd, &mp, uint32(16))
        if mn > 0:
-            # 【诊断·临时】首个鼠标包：证明 中断→devfs→本进程 链路已通
-            if _mouse_logged == 0:
-                _mouse_logged = 1
-                _mb: [128]char
-                viperlib.snprintf(&_mb, 128, "[explorer] mouse pkt n=%d btn=%d\n", mn, int(mp[0]))
-                devfs.serial_puts(&_mb)
            moved: int = 0
            wheel: int = 0
            if mn >= 10:
@@ -2019,54 +1977,8 @@ class DeskServer:
        # 脏行里，只靠后续增量渲染会永远留在屏幕上。
        self.mark_all()
        self.render()
-        # 【临时诊断】首帧结果：back[0] 是"合成出来的像素"，fb[0] 是"提交到屏幕的像素"。
-        # 两者都等于背景色 ⇒ 通路正常（问题在别处）；back 有值而 fb 为 0 ⇒ 提交路径断了。
-        _f1: [176]char
-        # 额外取一个任务栏行上的像素（底边往上 8 行）：期望 0xff202020（任务栏底色 32,32,32）。
-        # 它能证明"首帧确实把任务栏也提交到了 fb"，从而把问题限定在"窗口合成"或"显示侧"。
-        _tb_y: int = self.fb_h - 8
-        _tb_px: uint32 = self.fb[_tb_y * self.pitch_px + 2]
-        viperlib.snprintf(&_f1, 176, "[explorer] frame1 back0=0x%x fb0=0x%x tb=0x%x w=%d h=%d pitch_px=%d\n",
-                          self.back[0], self.fb[0], _tb_px, self.fb_w, self.fb_h, self.pitch_px)
-        devfs.serial_puts(&_f1)
-        _fc: int = 0   # 【临时诊断】帧计数
        while True:
            self.poll_requests()
            self.poll_input()
            self.render()
-            # 【临时诊断】每 240 帧打一次：槽位数、最上层窗口的矩形/缓冲偏移，以及该窗口中心
-            # 已合成出来的像素（用来判断"窗口到底有没有被合成"）。
-            _fc = _fc + 1
-            if (_fc % 240) == 0:
-                # 【临时诊断】统计槽位 + 最上层窗口的矩形/缓冲偏移，并取窗口中心那个已合成像素。
-                _uc: int = 0
-                _tz: int = -1
-                _tw: int = -1
-                for _i in range(desk.DESK_MAX_WIN):
-                    _s: desk.WinSlot* = self.slot(_i)
-                    if _s.used != 0: _uc += 1
-                    if _s.used != 0 and _s.active != 0 and _s.minimized == 0 and _s.z_order > _tz:
-                        _tz = _s.z_order
-                        _tw = _i
-                _px: uint32 = uint32(0)
-                _spx: uint32 = uint32(0)
-                _wx: int = -1
-                _wy: int = -1
-                _ww: int = -1
-                _wh: int = -1
-                _woff: uint32 = uint32(0)
-                if _tw >= 0:
-                    _ws: desk.WinSlot* = self.slot(_tw)
-                    _wx = _ws.ux; _wy = _ws.uy; _ww = _ws.w; _wh = _ws.h; _woff = _ws.fb_off
-                    _cxp: int = _wx + _ww / 2
-                    _cyp: int = _wy + _wh / 2
-                    if _cxp >= 0 and _cxp < self.fb_w and _cyp >= 0 and _cyp < self.fb_h:
-                        _px = self.back[_cyp * self.fb_w + _cxp]
-                    # 共享区里该窗口缓冲的首像素：app 到底有没有往这块内存里画
-                    _sbuf: uint32* = uint32*(self.shm + uint64(_woff))
-                    _spx = _sbuf[0]
-                _f2: [256]char
-                viperlib.snprintf(&_f2, 256, "[explorer] frame%d dirty=%d used=%d top=%d rect=%d,%d,%d,%d off=%u px=0x%x shm0=0x%x flush=%d\n",
-                                  _fc, self.dirty_any, _uc, _tw, _wx, _wy, _ww, _wh, _woff, _px, _spx, _flush_cnt)
-                devfs.serial_puts(&_f2)
            process.yield_cpu()
@@ -2,99 +2,52 @@ import vpsdk.devfs as devfs
 import vpsdk.desk as desk
 import vpsdk.process as process
 from stdint import *
-import viperlib
 import desk_server


-def _dbg(msg: const str):
-    # S4：改走 /dev/serial0（SERIAL_PUTS 私有 syscall 已删除）
-    devfs.serial_puts(msg)
-
-
@__attribute__(section(".text.startup"), aligned(16))
 export def _start() -> int:
-    _dbg("[explorer] start\n")
-
    # 1) 打开 framebuffer 设备，问几何，再映射成线性地址
    fb_fd: int = devfs.fb_open()
    if fb_fd < 0:
-        _dbg("[explorer] open /dev/fb0 FAILED\n")
        process.exit(1)
        return 0

-    # fb_get_info 改为出参 + 返回码：必须判返回码，否则拿到的是"未写入的残留"
-    # （旧写法按值返回 FbInfo，只见前 16 字节有效 ⇒ size/phys 打出垃圾）。
+    # fb_get_info returns the geometry through an out parameter and a status code.
    info: devfs.FbInfo
    _fb_ret: int = devfs.fb_get_info(fb_fd, &info)
    if _fb_ret != 0:
-        _dbg("[explorer] FB_GET_INFO FAILED\n")
        process.exit(1)
        return 0

-    buf: [160]char
-    viperlib.snprintf(&buf, 160,
-        "[explorer] fb %ux%u pitch=%u fmt=%u size=%lu phys=0x%lx\n",
-        info.width, info.height, info.pitch, info.format, info.size, info.phys)
-    _dbg(&buf)
-
    if info.pitch == 0 or info.size == 0:
-        # 几何为 0 ⇒ 内核侧登记/回填没成功（例如注册时传进去的 width/height 是 0）。
-        # 继续走只会以 pitch=0 画崩，这里 fail-fast 并把原因说清楚。
-        _dbg("[explorer] fb geometry invalid (pitch/size=0)\n")
        process.exit(1)
        return 0

    fb_va: uint64 = devfs.fb_map(fb_fd, info.size)
    if fb_va == 0:
-        _dbg("[explorer] mmap /dev/fb0 FAILED\n")
        process.exit(1)
        return 0

-    buf2: [96]char
-    viperlib.snprintf(&buf2, 96, "[explorer] fb mapped at 0x%lx\n", fb_va)
-    _dbg(&buf2)
-
-    # 2) 屏幕几何/映射地址已打印（上面两行），像素通路由此验证；真正的绘制在服务端。
    fb: uint32* = uint32*(fb_va)

-    # 【临时诊断】写一个哨兵像素再回读：区分"映射不可写/不可回读"与"合成逻辑没画东西"。
-    # 确认后删除。
-    fb[0] = uint32(0x0000FF00)
-    buf_s: [96]char
-    viperlib.snprintf(&buf_s, 96, "[explorer] fb[0] wrote=0xFF00 readback=0x%x\n", fb[0])
-    _dbg(&buf_s)
-
-    # 4) 输入设备可达性：能 open 到就说明 /dev/* 通路已打通
-    #    （真正读事件、接管窗口合成放到 S3 —— 内核桌面此刻还在抢同一个 PS/2 口）。
+    # Input devices are reachable once they can be opened.
    kfd: int = devfs.kbd_open()
    mfd: int = devfs.mouse_open()
-    buf3: [96]char
-    viperlib.snprintf(&buf3, 96, "[explorer] input: kbd=%d mouse=%d\n", kfd, mfd)
-    _dbg(&buf3)

-    # 5) 挂上 /dev/desk 共享区并格式化 —— explorer 是图形壳，共享区由它初始化，
-    #    app 侧只 desk_ready() 校验。这里先把头打出来证明 IPC 底座可用。
+    # Attach and format the /dev/desk shared area used by the window server.
    desk_fd: int = desk.desk_open()
    if desk_fd < 0:
-        _dbg("[explorer] open /dev/desk FAILED\n")
        process.exit(1)
        return 0
    shm: uint64 = desk.desk_map(desk_fd)
    if shm == 0:
-        _dbg("[explorer] mmap /dev/desk FAILED\n")
        process.exit(1)
        return 0
    desk.desk_format(shm, info.width, info.height, info.pitch)
-    hdr: desk.DeskHeader* = desk.DeskHeader*(shm + desk.desk_header_off())
-    buf4: [144]char
-    viperlib.snprintf(&buf4, 144,
-        "[explorer] desk shm=0x%lx ready=%d slot=%lu arena=%u\n",
-        shm, hdr.ready, uint64(desk.desk_slot_size()), hdr.arena_off)
-    _dbg(&buf4)

-    # 6) 进入窗口服务端主循环（永不返回）：请求环 + 输入 + 合成。
+    # Enter the window server loop: request ring, input and composition.
    srv: desk_server.DeskServer = desk_server.DeskServer()
    srv.init(fb, int(info.width), int(info.height), int(info.pitch), info.format, shm, kfd, mfd, fb_fd)
-    _dbg("[explorer] desk server running\n")
    srv.serve()
    return 0