Debuggin Kernel Headers
=========================


If the ``configure`` script is still not finding the four headers (``dmapi.h``, ``mm.h``, ``linux/module.h``, and ``sys/jfsdmapi.h``) even after defining ``CPPFLAGS="-I/usr/src/k-ver/include"``, there could be several reasons for this. Let’s troubleshoot step by step:

----

1. **Verify the Path in** ``CPPFLAGS``

   - Ensure that the path specified in ``CPPFLAGS`` is correct and contains the required headers.
   - Run the following command to check if the headers exist in the specified directory:

     .. code-block:: bash

        ls /usr/src/k-ver/include/dmapi.h /usr/src/k-ver/include/mm.h /usr/src/k-ver/include/linux/module.h /usr/src/k-ver/include/sys/jfsdmapi.h

     If any of these files are missing, the ``configure`` script will not find them.

----

2. **Check Subdirectories**

   - Some headers might be located in subdirectories. For example:
     - ``linux/module.h`` is typically located in ``/usr/src/k-ver/include/linux/module.h``.
     - ``sys/jfsdmapi.h`` might be in ``/usr/src/k-ver/include/sys/jfsdmapi.h``.
   - Ensure that the ``CPPFLAGS`` path points to the base directory (``/usr/src/k-ver/include``), and the ``configure`` script is correctly appending the subdirectories.

----

3. **Kernel Version Mismatch**

   - The headers in ``/usr/src/k-ver/include`` must match the version of the running kernel. If there is a mismatch, the headers might not be compatible, and the ``configure`` script might fail to recognize them.
   - Check the kernel version:

     .. code-block:: bash

        uname -r

   - Verify that ``/usr/src/k-ver`` corresponds to the same version.

----

4. **Use Groups for Development**

   - To manage access to the ``include`` directory for multiple users, consider using a dedicated group (e.g., ``developers``).
   - Follow these steps:

     1. Create the ``developers`` group (if it doesn’t exist):

        .. code-block:: bash

           sudo groupadd developers

     2. Change the group ownership of the ``include`` directory:

        .. code-block:: bash

           sudo chgrp -R developers /usr/src/k-ver/include

     3. Grant read permissions to the ``developers`` group:

        .. code-block:: bash

           sudo chmod -R g+r /usr/src/k-ver/include

     4. Add users (e.g., ``root`` and your regular user) to the ``developers`` group:

        .. code-block:: bash

           sudo usermod -aG developers root
           sudo usermod -aG developers $USER

     5. Verify group membership:

        .. code-block:: bash

           groups $USER
           groups root

     6. Log out and log back in for the changes to take effect, or use:

        .. code-block:: bash

           newgrp developers

   - This ensures that all members of the ``developers`` group (including ``root`` and regular users) have read access to the ``include`` directory.


4.99 **Analyzing the Permission String**

The permission string for the directory ``/usr/src/k-ver/include`` is:

.. code-block:: text

   drwxr-xr-x. 28 root developers /usr/src/k-ver/include

Here’s what it means:

1. **File Type**:
   - ``d``: The entry is a directory.

2. **Permissions**:
   - ``rwxr-xr-x``: The permissions are divided into three groups:
     - **Owner** (``root``): Has read, write, and execute permissions (``rwx``).
     - **Group** (``developers``): Has read and execute permissions (``r-x``).
     - **Others**: Have read and execute permissions (``r-x``).

3. **Extended ACL**:
   - The ``.`` at the end indicates that the directory has an extended ACL. Use ``getfacl`` to view the additional permissions:

     .. code-block:: bash

        getfacl /usr/src/k-ver/include

4. **Number of Links**:
   - ``28``: The directory has 28 hard links (typically representing subdirectories).

5. **Owner and Group**:
   - The directory is owned by ``root`` and belongs to the ``developers`` group.

6. **Directory Path**:
   - The path to the directory is ``/usr/src/k-ver/include``.

**Is This Configuration Appropriate?**

- **For Development**: If the ``developers`` group needs read and execute access, this configuration is appropriate.
- **For Write Access**: If the group needs to modify files, grant write permissions:

  .. code-block:: bash

     sudo chmod -R g+w /usr/src/k-ver/include

- **For Security**: Restrict access further if the directory contains sensitive files.

----

5. ``configure`` **Script Behavior**

   - The ``configure`` script might not be using ``CPPFLAGS`` correctly. To verify, add debugging output to the ``configure.ac`` file:

     .. code-block:: m4

        AC_MSG_CHECKING([for CPPFLAGS])
        AC_MSG_RESULT([$CPPFLAGS])

   - Rebuild the ``configure`` script:

     .. code-block:: bash

        autoreconf -fvi

   - Run ``./configure`` again and check if the ``CPPFLAGS`` value is correctly printed.

----

6. **Header Dependencies**

   - Some headers might depend on other headers or macros being defined. For example, ``linux/module.h`` might require ``LINUX_VERSION_CODE`` or other kernel-specific macros.
   - Modify the ``AC_CHECK_HEADERS`` macro to include necessary dependencies:

     .. code-block:: m4

        AC_CHECK_HEADERS([dmapi.h mm.h linux/module.h sys/jfsdmapi.h], [], [], [
          #include <linux/version.h>
          #include <sys/types.h>
        ])

----

7. **Use** ``--with-linux-dir`` **Instead of** ``CPPFLAGS``

   - If the ``configure`` script supports the ``--with-linux-dir`` option, use it instead of manually setting ``CPPFLAGS``:

     .. code-block:: bash

        ./configure --with-linux-dir=/usr/src/k-ver

   - This option is specifically designed to handle kernel headers and might work better than manually setting ``CPPFLAGS``.

----

8. **Check** ``config.log`` **for Errors**

   - The ``config.log`` file contains detailed information about why the ``configure`` script failed to find the headers.
   - Open ``config.log`` and search for the header names (e.g., ``dmapi.h``, ``mm.h``, etc.) to see the exact error messages.

----

9. **Manually Verify Header Compilation**

   - Create a small test program to check if the headers can be included:

     .. code-block:: c

        #include <dmapi.h>
        #include <mm.h>
        #include <linux/module.h>
        #include <sys/jfsdmapi.h>

        int main() {
            return 0;
        }

   - Compile the program with ``CPPFLAGS``:

     .. code-block:: bash

        gcc $CPPFLAGS -o test test.c

   - If the compilation fails, the issue is likely with the headers themselves or their dependencies.

----

10. **Install Missing Kernel Headers**
 
    - If the headers are missing from ``/usr/src/k-ver/include``, you might need to install the appropriate kernel headers package. For example:

      .. code-block:: bash

         sudo apt-get install linux-headers-$(uname -r)

    - Alternatively, manually install the headers from the kernel source.

----

Summary of Steps:
~~~~~~~~~~~~~~~~~~

1. Verify the headers exist in ``/usr/src/k-ver/include``.
2. Check for subdirectories and permissions.
3. Ensure the kernel version matches.
4. Debug ``CPPFLAGS`` usage in the ``configure`` script.
5. Use ``--with-linux-dir`` if available.
6. Check ``config.log`` for detailed errors.
7. Manually test header compilation.

If the issue persists after these steps, let me know, and we can dive deeper into the specific errors in ``config.log``.