CI: Add CI job for testing

androm3da · androm3da · commit 4f0de6ec99cd · 2025-11-30T18:26:24.000-06:00
diff --git a/.github/workflows/hexagon-ci.yml b/.github/workflows/hexagon-ci.yml
@@ -0,0 +1,120 @@
+name: Hexagon QEMU CI
+
+on:
+  push:
+    branches: [ master, hex-next ]
+  pull_request:
+    branches: [ master, hex-next ]
+  workflow_dispatch:
+
+jobs:
+  build-and-test:
+    name: ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-22.04
+            target_list: hexagon-linux-user,hexagon-softmmu
+            target_list_master: hexagon-linux-user
+          - os: windows-latest
+            target_list: hexagon-softmmu
+            target_list_master: hexagon-softmmu
+
+    steps:
+    - name: Checkout QEMU
+      uses: actions/checkout@v4
+
+    # Ubuntu setup
+    - name: Install Ubuntu dependencies
+      if: runner.os == 'Linux'
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y \
+          build-essential \
+          ninja-build \
+          pkg-config \
+          libglib2.0-dev \
+          libfdt-dev \
+          libpixman-1-dev \
+          libslirp-dev \
+          python3-venv \
+          python3-pip
+
+    # Windows setup
+    - name: Setup MSYS2 for Windows
+      if: runner.os == 'Windows'
+      run: |
+        # GitHub Actions Windows runners come with MSYS2 pre-installed
+        # Update package database
+        C:\msys64\usr\bin\bash.exe -lc "pacman --noconfirm -Sy"
+
+        # Install required packages
+        C:\msys64\usr\bin\bash.exe -lc "pacman --noconfirm -S mingw-w64-x86_64-toolchain mingw-w64-x86_64-glib2 mingw-w64-x86_64-pixman mingw-w64-x86_64-pkgconf mingw-w64-x86_64-libslirp mingw-w64-x86_64-dtc mingw-w64-x86_64-ninja mingw-w64-x86_64-python3"
+
+        # Add MSYS2 to PATH
+        echo "C:\msys64\mingw64\bin" >> $env:GITHUB_PATH
+        echo "C:\msys64\usr\bin" >> $env:GITHUB_PATH
+
+    # Configure and build
+    - name: Configure QEMU (Ubuntu)
+      if: runner.os == 'Linux'
+      run: |
+        mkdir build
+        cd build
+        TARGET_LIST=${{ github.ref == 'refs/heads/master' && matrix.target_list_master || matrix.target_list }}
+        ../configure \
+          --target-list=$TARGET_LIST \
+          --enable-slirp \
+          --enable-fdt \
+          --enable-plugins \
+          --disable-docs
+
+    - name: Configure QEMU (Windows)
+      if: runner.os == 'Windows'
+      run: |
+        C:\msys64\usr\bin\bash.exe -lc "export PATH=/mingw64/bin:\$PATH && cd '${{ github.workspace }}' && mkdir build && cd build && TARGET_LIST=${{ github.ref == 'refs/heads/master' && matrix.target_list_master || matrix.target_list }} && ../configure --target-list=\$TARGET_LIST --enable-slirp --enable-fdt --enable-plugins --disable-docs --cross-prefix=x86_64-w64-mingw32-"
+
+    - name: Build QEMU (Ubuntu)
+      if: runner.os == 'Linux'
+      run: |
+        cd build
+        ninja
+
+    - name: Build QEMU (Windows)
+      if: runner.os == 'Windows'
+      run: |
+        C:\msys64\usr\bin\bash.exe -lc "export PATH=/mingw64/bin:\$PATH && cd '${{ github.workspace }}/build' && ninja"
+
+    # Test hexagon-linux-user (Ubuntu only)
+    - name: Test hexagon-linux-user
+      if: runner.os == 'Linux'
+      run: |
+        cd build
+        make check-tcg
+
+    # Test hexagon-softmmu (Ubuntu)
+    - name: Test hexagon-softmmu (Ubuntu)
+      if: runner.os == 'Linux'
+      run: |
+        cd build
+        make check-functional
+
+    # Test hexagon-softmmu (Windows)
+    - name: Test hexagon-softmmu (Windows)
+      if: runner.os == 'Windows'
+      run: |
+        C:\msys64\usr\bin\bash.exe -lc "export PATH=/mingw64/bin:\$PATH && cd '${{ github.workspace }}/build' && make check-functional"
+
+    # Upload test logs
+    - name: Upload test logs
+      if: always()
+      uses: actions/upload-artifact@v4
+      with:
+        name: test-logs-${{ matrix.os }}
+        path: |
+          build/tests/results/
+          build/meson-logs/
+          build/**/*.log
+        retention-days: 7
diff --git a/target/hexagon/cpu.h b/target/hexagon/cpu.h
@@ -144,6 +144,7 @@ typedef struct CPUArchState {
     target_ulong k0_lock_count;
     CPUHexagonTLBContext *hex_tlb;
     GList *dir_list;
+    GHashTable *dir_paths;
 #endif
     target_ulong next_PC;
     target_ulong new_value_usr;
diff --git a/target/hexagon/hexswi.c b/target/hexagon/hexswi.c
@@ -635,55 +635,87 @@ static void sim_handle_trap0(CPUHexagonState *env)
 
     case HEX_SYS_OPENDIR:
     {
-        DIR *dir;
-        char buf[BUFSIZ];
+        char dir_path[BUFSIZ];
+        GDir *dir;
+        GError *gerr = NULL;
         int rc = 0, err = 0;
 
+        /* Read directory path string, following arch-independent pattern */
         int i = 0;
         do {
-            hexagon_read_memory(env, swi_info + i, 1, &buf[i], retaddr);
+            hexagon_read_memory(env, swi_info + i, 1, &dir_path[i], retaddr);
             i++;
-        } while (buf[i - 1]);
+            if (i >= BUFSIZ - 1) {
+                semi_cb(cs, -1, ENAMETOOLONG);
+                return;
+            }
+        } while (dir_path[i - 1]);
 
-        dir = opendir(buf);
+        dir = g_dir_open(dir_path, 0, &gerr);
         if (dir != NULL) {
+            /* Initialize dir_paths hash table if not already done */
+            if (!env->dir_paths) {
+                env->dir_paths = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+                                                       NULL, g_free);
+            }
+            /* Store the directory path for later use in readdir */
+            g_hash_table_insert(env->dir_paths, dir, g_strdup(dir_path));
             env->dir_list = g_list_append(env->dir_list, dir);
             rc = g_list_index(env->dir_list, dir) + DIR_INDEX_OFFSET;
         } else {
-            err = errno;
+            err = gerr ? gerr->code : ENOENT;
+            if (gerr) {
+                g_error_free(gerr);
+            }
         }
         semi_cb(cs, rc, rc != 0 ? 0 : err);
         break;
     }
 
     case HEX_SYS_READDIR:
     {
-        struct dirent *host_dir_entry = NULL;
+        const gchar *entry_name = NULL;
         int dir_index = swi_info - DIR_INDEX_OFFSET;
-        DIR *dir = g_list_nth_data(env->dir_list, dir_index);
+        GDir *dir = g_list_nth_data(env->dir_list, dir_index);
         uint32_t rc = 0, err = 0;
 
         if (dir) {
-            errno = 0;
-            host_dir_entry = readdir(dir);
-            if (host_dir_entry == NULL) {
-                err = errno;
+            entry_name = g_dir_read_name(dir);
+            if (entry_name == NULL) {
+                err = 0; /* End of directory */
             }
         } else {
             err = EBADF;
         }
 
-        if (host_dir_entry) {
+        if (entry_name) {
             uint32_t guest_dir_entry = arch_get_thread_reg(env, HEX_REG_R02);
-            hexagon_write_memory(env, guest_dir_entry, 4, host_dir_entry->d_ino,
-                                 retaddr);
-            for (int i = 0; i < sizeof(host_dir_entry->d_name); i++) {
-                hexagon_write_memory(env, guest_dir_entry + 4 + i, 1,
-                                     host_dir_entry->d_name[i], retaddr);
-                if (!host_dir_entry->d_name[i]) {
-                    break;
+            uint32_t ino = 1; /* Default fallback */
+
+            const char *dir_path = g_hash_table_lookup(env->dir_paths, dir);
+            if (dir_path) {
+                char *full_path = g_build_filename(dir_path, entry_name, NULL);
+                if (full_path) {
+                    struct stat st;
+                    if (stat(full_path, &st) == 0) {
+                        if (st.st_ino != (uint32_t)st.st_ino) {
+                            g_free(full_path);
+                            semi_cb(cs, -1, EOVERFLOW);
+                            break;
+                        }
+                        ino = (uint32_t)st.st_ino;
+                    }
+                    g_free(full_path);
                 }
             }
+
+            hexagon_write_memory(env, guest_dir_entry, 4, ino, retaddr);
+
+            int name_len = strlen(entry_name) + 1;
+            for (int i = 0; i < name_len; i++) {
+                hexagon_write_memory(env, guest_dir_entry + 4 + i, 1,
+                                     entry_name[i], retaddr);
+            }
             rc = guest_dir_entry;
         }
         semi_cb(cs, rc, err);
@@ -692,16 +724,19 @@ static void sim_handle_trap0(CPUHexagonState *env)
 
     case HEX_SYS_CLOSEDIR:
     {
-        DIR *dir;
-        int ret = -1, err;
+        GDir *dir;
+        int ret = -1, err = 0;
         int dir_index = swi_info - DIR_INDEX_OFFSET;
 
         dir = g_list_nth_data(env->dir_list, dir_index);
         if (dir != NULL) {
-            ret = closedir(dir);
-            if (ret != 0) {
-                err = errno;
+            /* Remove from hash table before closing */
+            if (env->dir_paths) {
+                g_hash_table_remove(env->dir_paths, dir);
             }
+            g_dir_close(dir);
+            env->dir_list = g_list_remove(env->dir_list, dir);
+            ret = 0;
         } else {
             err = EBADF;
         }
