Contribute/BiteSizedTasks: Difference between revisions

From QEMU
(Add a task for cleaning up bad LGPL version 2 statements)
(The watchdog_perform_action() cleanup has been done (apart from spapr, which is too complicated to be bite-sized))
 
(35 intermediate revisions by 8 users not shown)
Line 1: Line 1:
This list is in the process of being re-evaluated and migrated to the [https://gitlab.com/qemu-project/qemu/-/issues QEMU issue tracker] using the [https://gitlab.com/qemu-project/qemu/-/issues?label_name%5B%5D=Bite+Sized Bite Sized] issue label.
'''For QEMU maintainers''': Please add your new suggestions to the [https://gitlab.com/qemu-project/qemu/-/issues issue tracker] instead, and add the [https://gitlab.com/qemu-project/qemu/-/issues?label_name%5B%5D=Bite+Sized Bite Sized label]. Please migrate any existing still relevant ideas to the issue tracker and remove them from this page afterward.
'''For new contributors''': Before starting on one of the tasks on this page, you should check the [https://lists.gnu.org/archive/html/qemu-devel/ mailing list archives] to ensure no one else has recently submitted similar cleanups for the same task. If nobody has, and the task appears valid, please reach out on the [[Contribute/MailingLists|QEMU development mailing list]] and let us know you'd like to start working on the issue. Please CC: John Snow <jsnow AT redhat.com> when doing so, they'll help get you assigned a GitLab issue and find the right points of contact.
For tasks on the issue tracker or on this page, patches are still handled by submitting patches to the mailing list and not via Gitlab merge requests. Before submitting a patch to the mailing list, please make sure that you've read and understood the [https://www.qemu.org/docs/master/devel/submitting-a-patch.html patch submission] page.
__TOC__
__TOC__
'''Note''': Before starting on one of these tasks, it would be wise to double-check the list archives to ensure no one else has recently submitted similar cleanups for the same task. And before submitting a patch to the mailing list, please make sure that you've read and understood the [[Contribute/SubmitAPatch]] page.
 
== General Notes ==
 
In many cases, items on this page describe tasks that might apply to many files in QEMU's sources. In this case, you shouldn't try to solve the problem for the whole of QEMU all at once. Instead, pick a small part of it, ideally related to what you're interested in, and look only at the file or files relevant to that. (For instance, if you're interested in Arm emulation, look at whether one of the tasks affects an Arm device model source file.) It's likely to be more useful to you if you take a particular part of the codebase, and make various different cleanups to it, thus gradually becoming more familiar with it, better able to test it, and so on, rather than trying to make one cleanup to many different parts of QEMU.
 
Where there is a gitlab issue for a task, that will usually have more detail than the entry on this page; gitlab issues generally are probably more likely to have been defined in a way that will make them tractable for a first-time contributor.
 
Some of these tasks are described very briefly and somewhat cryptically. If you're not sure what a task involves, then feel free to ask for clarification on the qemu-devel mailing list, or the contact person for the task (if the task has been marked with a contact).
 
== Gitlab "Bite Sized" Issues ==
 
Issues tagged "[https://gitlab.com/qemu-project/qemu/-/issues?label_name%5B%5D=Bite+Sized Bite Sized]" on the issue tracker may be good candidates for first contributions. If you're interested in solving one of these problems, please register for a Gitlab account and participate in the discussion on the issue so it will be evident to others that you are engaged in researching and fixing the issue.
 
The issues may sometimes appear to be cryptic or vague. Don't hesitate to ask for more information if the task is not clear. If there is no obvious point of contact from the issue page itself, please reach out for help on the [[Contribute/MailingLists|qemu development mailing list]].


== API conversion ==
== API conversion ==
* Replace manual qemu_mutex_lock() and qemu_mutex_unlock() calls with QEMU_LOCK_GUARD() where it makes the code easier to read. See [[ToDo/LockGuards]] for details.
* Replace manual qemu_mutex_lock() and qemu_mutex_unlock() calls with QEMU_LOCK_GUARD() where it makes the code easier to read. See [[ToDo/LockGuards]] for details.
* Remove leading underscores from #defines: Identifiers with leading underscores followed by another underscore or a capital letter are reserved by the C standard. Use something like <code>grep 'define[ \t]*_[A-Z_]' $(find -name \*.h | grep -v roms | grep -v linux)</code> to find files that might violate this rule, double-check whether the file should be cleaned up or not (some files that are derived from other sources like the Linux headers should not be changed), and then send patches to remove the leading underscores if it is OK there. (contact: THH)
* Look for uses of malloc, and convert them to g_new or similar. See the fuller writeup in [https://gitlab.com/qemu-project/qemu/-/issues/1798 the issue on the bug tracker] for more information and a list of the remaining places that need conversion (and the places that don't need it).
* Look for uses of malloc, and convert them to g_new or similar (see HACKING for more details on allocation interface usage). Likewise, convert calloc to g_new0 and friends. Drop return value checks unless using g_try_new/g_try_new0. (This needs to be done for one data structure at a time, because an allocation with malloc must be freed with free but an allocation with g_malloc must be freed with g_free. So you need to do a bit of analysis of the code to see where an allocation may be later freed.) Please ignore the mallocs in libdecnumber and tests/tcg/.
* [[ToDo/CodeTransitions#Makefile|Associate external libraries with the object files that actually use them]]
* Replace calls to functions named cpu_physical_memory_* with address_space_*.
* Replace calls to functions named cpu_physical_memory_* with address_space_*.
* Replace calls to object_child_foreach() with object_child_foreach_recursive() when applicable: nvdimm_device_list, nmi_monitor_handle, find_sysbus_device, pc_dimm_slot2bitmap, build_dimm_list.
* Replace calls to object_child_foreach() with object_child_foreach_recursive() when applicable: nvdimm_device_list, nmi_monitor_handle, find_sysbus_device, pc_dimm_slot2bitmap, build_dimm_list.
* The [[ToDo/CodeTransitions]] page tracks ongoing internal QEMU API transitions. Most are not trivial but it's a good source of ideas, and some items should be doable for newcomers, too, e.g.:
* The [[ToDo/CodeTransitions]] page tracks ongoing internal QEMU API transitions. Most are not trivial but it's a good source of ideas, and some items should be doable for newcomers, too.
** Coding whitespace style: Some files in the util/ and other folders use TABs for indentation instead of spaces, so sending patches that affect these files usually trigger a warning by the checkpatch.pl script. Identify the files with the wrong indentations and send a patch to adapt the files to the QEMU coding style conventions (i.e. indent with 4 spaces instead of TABs). (contact: THH)
* QSIMPLEQ_REMOVE and QSLIST_REMOVE are inefficient. Check if they could be replaced by QSIMPLEQ_REMOVE_HEAD and QSLIST_REMOVE_HEAD; if not, use a QTAILQ or QLIST respectively.
* Clean up wrong usage of FALSE and TRUE in places that use "bool" from stdbool.h. FALSE and TRUE (with capital letters) are the constants defined by glib for being used with the "gboolean" type of glib. So code that uses TRUE or FALSE for "gboolean" variables or calls functions from glib is fine. But some parts of the code also use TRUE and FALSE for variables that are declared as "bool" (the type from <stdbool.h>). These code parts should be using ''true'' and ''false'' (without capital letters) instead. (contact: THH)
* Introduce a better alternative to strncpy. QEMU uses strncpy whenever the destination needs to be zeroed entirely, for example to avoid data leaks. Add a new function qemu_strncpy that asserts that the destination buffer is big enough to fit strlen(source)+1 bytes.  Also add a new function qemu_strncpy_nonul that asserts that the destination buffer is big enough to fit strlen(source) bytes (thus not guaranteeing NUL termination).  Replace uses of strncpy throughout the QEMU sources.


== Code Modernization ==
== Code Modernization ==
* Convert routines with multiple goto exit-paths to use g_autoptr/g_autofree to handle clean-up and allow direct returns
* Convert routines with multiple goto exit-paths to use g_autoptr/g_autofree to handle clean-up and allow direct returns
* Replace common idioms like '''if (s->len > 0) { g_string_append(s, ", "); } g_string_append(s, "foo")''' with common helper function
* Replace common idioms like '''if (s->len > 0) { g_string_append(s, ", "); } g_string_append(s, "foo")''' with common helper function
 
* Replace hand-coded uri_string_escape/uri_string_unescape with glib equivalents, for bonus points unify open-coded to/from hex routines with the gdbstub equivilents
== Header cleanups ==
* Clean up includes to reduce compile time. There are many "touch it, recompile the world" headers in the QEMU project. See http://lists.nongnu.org/archive/html/qemu-devel/2018-01/msg07189.html for a list of headers (not all of them can be cleaned up, though) and http://lists.nongnu.org/archive/html/qemu-devel/2018-01/msg06941.html for examples how to get rid of them. (contact: THH)
* Run '<code>grep -rl "Temple Place" *</code>' to find some files that still have the old address of the FSF (they moved to a different location since a couple of years already). Replace the address with the URL to the GPL license text instead (or maybe even replace the section with a SPDX identifier instead? ==> might need some discussion on the mailing list first)
* Run '<code>grep -l Lesser $(grep -rl "version 2 " * )</code>' to find files that claim to be licensed under the "Lesser General Public License version 2" (in the sense of "version 2.0"). There never was a Lesser GPL version 2.0 - in that version, the license was still called "Library General Public License". So it is quite obvious that "version 2.1" was meant here instead. Thus send patches to replace "version 2" with "version 2.1". See e.g. commit b7cbb8741b40b7cd4d as an example.
 
== Device models ==
* Categorize devices: Run "<code>qemu-system-x86_64 -device help</code>" or "<code>qemu-system-arm -M none -device help</code>" and look for devices that are in the "uncategorized devices" section. Ideally, each device should have a category, even if it's just the "misc devices" category. Identify the source file of such an uncategorized devices and set an appropriate DEVICE_CATEGORY bit in its device class categories field (use "<code>grep -r DEVICE_CATEGORY hw/</code>" to see some examples). (contact: THH)
* Look for invocations of qemu_system_reset_request() in hw/.  Whenever they correspond to some kind of watchdog that has triggered, change to watchdog_perform_action().
* "QOMify" devices: Some devices are still not adapted to the recent QEMU Object Model (QOM) yet. Try to identify such devices and convert them to the recent QOM device model. Details can be found in Andreas Färber's talk during KVM Forum 2013: https://www.youtube.com/watch?v=9LXvZOrHwjw . Note that this is a rather advanced task already. (contact: THH)
* Add support for attribute((bitwise)), tag structure fields and use that for static checking of structure endian-ness accesses
* Implement the "Backend program conventions" from [https://git.qemu.org/?p=qemu.git;a=blob_plain;f=docs/interop/vhost-user.rst;hb=HEAD vhost-user.rst], including the standard command-line options and vhost-user.json for <code>contrib/vhost-user-blk/</code> and <code>contrib/vhost-user-scsi/</code>.  See <code>contrib/vhost-user-input/</code> for an example.


== Error checking ==
== Error checking ==
* Add checks for negative return value to uses of load_image_targphys, get_image_size, event_notifier_init, msix_init.
* Use qemu_strtol/qemu_strtoul/qemu_strtoll/qemu_strtoull more. (contact: eblake)
* Use qemu_strtol/qemu_strtoul/qemu_strtoll/qemu_strtoull more. (contact: eblake)
* Make qemu_thread_create return a flag to indicate if it succeeded rather than failing with an error; make all callers check it.
* Using "NULL" for errp in case "it cannot fail" should be avoided. If there is an unexpected error generated, it will simply be ignored. Making use of "&error_abort" instead allows us to catch unexpected errors.
* Dereferencing errp to check for errors is wrong "because errp may be NULL!". Making use of a local Error * and call error_propagate() instead, as explained in "qapi/error.h".
* Look for code that checks for errno == EINTR. If the code is simply doing something like '<code>do { x = expr(); } while (x == -1 && errno == EINTR);</code>', you can replace the surrounding loop with the TFR() macro from include/qemu-common.h instead.
* strerror() is not thread safe (completely unsafe in FreeBSD, while on glibc it threadsafe for defined errno values but non-safe for out-of-range values); the code base needs to be audited for a conversion to g_strerror() (which is an easy-to-use wrapper around the thread-safe strerror_r() function)
== Dead code removal ==
* hw/display contains files named *_template.h.  These are included many times with different values of the DEPTH macro.  However, only the DEPTH == 32 case is used.  Remove support for DEPTH != 32 in the template headers and in the file that include them.  See also https://lists.gnu.org/archive/html/qemu-devel/2018-03/msg03247.html
* Remove the "Error **" argument from functions named *_unrealize in hw/
* Use the technique described at https://blog.flameeyes.eu/2008/01/today-how-to-identify-unused-exported-functions-and-variables to identify unused global functions and variables, try to decide whether it's a good idea to remove the detected code fragments and send (single) patches to remove them if applicable. (contact: THH)


== Compiler-driven cleanups ==
== Compiler-driven cleanups ==
* Use of -Wshadow while compiling can prevent legitimate bugs, but can't be enabled until we first clean up the code base to avoid shadowed declarations.
* Use of -Wframe-larger-than=4096 can prevent the use of potential security flaws caused by stack overflows made possible with over-large stack allocations.
* Use of -Wvla and -Wframe-larger-than=4096 can prevent the use of potential security flaws caused by stack overflows made possible with variable-length arrays or other over-large stack allocations.
* The following functions have very large stack frames (as obtained with -Wstack-usage=16383), mostly due to huge arrays.  Make the stack array smaller and allocate on the heap in the rare case that the data does not fit in the small array:
* The following functions have very large stack frames (as obtained with -Wstack-usage=16383), mostly due to huge arrays.  Make the stack array smaller and allocate on the heap in the rare case that the data does not fit in the small array:


Line 58: Line 52:
  hw/virtio/virtio.c                  qemu_put_virtqueue_element      49216 bytes
  hw/virtio/virtio.c                  qemu_put_virtqueue_element      49216 bytes
  hw/net/opencores_eth.c              open_eth_start_xmit              65664 bytes
  hw/net/opencores_eth.c              open_eth_start_xmit              65664 bytes
hw/net/spapr_llan.c                  h_send_logical_lan              ~64Kbytes (uses alloca)
  hw/arm/nseries.c                    n8x0_init                        65728 bytes
  hw/arm/nseries.c                    n8x0_init                        65728 bytes
  net/net.c                            nc_sendv_compat                  69680 bytes
  net/net.c                            nc_sendv_compat                  69680 bytes
  net/socket.c                        net_socket_send                  69712 bytes
  net/socket.c                        net_socket_send                  69712 bytes
Note that this list is likely out of date. If you want to work on this you should start by identifying some functions worth looking at by building QEMU yourself with --extra-cflags=-Wstack-usage=16383 --disable-werror . Then you can capture the output of the compile process (e.g. with make -C build -j8 2>&1 | tee stack-usage.log) and look for the warnings in the log file. Come and talk to us on the qemu-devel list about this before putting much work into it -- there are quite a lot of functions with large or even theoretically unbounded stack usage, but not all of them are in places in the code where it's important.


== Tracing ==
== Tracing ==
* Add tracepoints.  All functions that are named ''something''_helper, and all functions mentioned in MemoryRegionOps are good candidates.
* Add tracepoints.  All functions that are named ''something''_helper, and all functions mentioned in MemoryRegionOps are good candidates.
* Convert DPRINTF() calls to tracepoints.
* Convert DPRINTF() calls to tracepoints (see https://gitlab.com/qemu-project/qemu/-/issues/1827 in the bug tracker for more details)


== Bitrot prevention ==
== Bitrot prevention ==
* Files with conditional debug statements should ensure that the printf is always compiled, and merely hidden behind <code>if (0)</code> when not debugging, rather than <code>#ifdef</code>'d out.  This prevents bitrot of the format string of the debug statement.  See this {{git|c691320faa6}} for an example.  Or, go one step further and convert the debug statements to tracepoints. (contact: eblake)
* Files with conditional debug statements should ensure that the printf is always compiled, and merely hidden behind <code>if (0)</code> when not debugging, rather than <code>#ifdef</code>'d out.  This prevents bitrot of the format string of the debug statement.  See this {{git|c691320faa6}} for an example.  Or, go one step further and convert the debug statements to tracepoints. For more detail on tracepoint conversion, see the issue in the bug tracker: https://gitlab.com/qemu-project/qemu/-/issues/1827 (contact: eblake)


== Functions that should be static ==
== Functions that should be static ==
* For example: vga_sync_dirty_bitmap, WC_CONFIG_STRING, WC_FULL_CONFIG_STRING, WC_MODEL_STRING, timer_put, vfio_region_ops, vfio_reset_handler, cpu_gen_init, monitor_read_bdrv_key_start, pdu_marshal, pdu_unmarshal, qcrypto_hmac_alg_map (crypto/hmap-nettle.c), spapr_tce_set_need_vfio, virtqueue_map, vnc_disconnect_finish, vnc_display_init, gicv3_full_update_noirqset, cpu_disable_ticks, cpu_enable_ticks, qemu_thread_exit (actually unused in thread-posix.c), qemu_egl_init_dpy_mesa, monitor_defs (3 occurrences), ppc405cr_init (unused?), apic_deliver_irq, pcie_host_mmcfg_map, pcie_host_mmcfg_unmap
* For example: vga_sync_dirty_bitmap, WC_CONFIG_STRING, WC_FULL_CONFIG_STRING, WC_MODEL_STRING, timer_put, vfio_region_ops, vfio_reset_handler, cpu_gen_init, monitor_read_bdrv_key_start, pdu_marshal, pdu_unmarshal, qcrypto_hmac_alg_map (crypto/hmap-nettle.c), spapr_tce_set_need_vfio, virtqueue_map, vnc_disconnect_finish, vnc_display_init, gicv3_full_update_noirqset, cpu_disable_ticks, cpu_enable_ticks, qemu_thread_exit (actually unused in thread-posix.c), qemu_egl_init_dpy_mesa, monitor_defs (3 occurrences), apic_deliver_irq, pcie_host_mmcfg_map, pcie_host_mmcfg_unmap
* tracetool-generated arrays (e.g. hw_mem_trace_events in the generated file hw/mem/trace.c) should be static.
* tracetool-generated arrays (e.g. hw_mem_trace_events in the generated file hw/mem/trace.c) should be static.
* The property types defined in hw/core/qdev-properties-system.c should be moved to other directories (e.g. hw/net for network-related property types). After doing this, some functions probably could become static, too.
* The property types defined in hw/core/qdev-properties-system.c should be moved to other directories (e.g. hw/net for network-related property types). After doing this, some functions probably could become static, too.
== Consistent option usage in documentation ==
qemu uses getopt_long_only(), which means that '-help' and '--help' are parsed identically; however, the short form is considered a crutch.  Meanwhile, other binaries in the qemu package use getopt_long(), which requires the double-dash form.  For consistency, all documentation examples should mention the long spelling with two dashes, especially since some options (like --object) have the same syntax between multiple binaries. Note: This task needs to be discussed first on the mailing list (contact: eblake)
== Potentially easy bugs ==
These are bugs that are really easy to reproduce, don't require any complicated setup and are probably some simple missing check - but there again we've not looked at them yet!
* A collection of command-lines that can crash QEMU can be generated with the scripts/device-crash-test tool from the QEMU sources (but currently, we seem to be in a good shape, so if you don't see any useful output, pick another task instead)
* Potentially easy bugs from the bugtracker:
** https://bugs.launchpad.net/qemu/+bug/304636 ("-hda FAT:. limited to 504MBytes")
** https://bugs.launchpad.net/qemu/+bug/603872 ("qemu-img image does not show percentage")
** https://bugs.launchpad.net/qemu/+bug/1620660 ("man page is missing suboptions for -display")
== Coroutines ==
QEMU uses coroutines for asynchronous operations, especially in the block layer (disk I/O, disk image formats, network storage protocols, etc).  The basics of coroutines are explained [http://blog.vmsplice.net/2014/01/coroutines-in-qemu-basics.html here].
* All functions that may yield (either directly or indirectly through a function they call) must be marked coroutine_fn in their function signature.  There is no build-time check for coroutine_fn, so it is accidentally missing in some places.  Search the code for function names that contain _co_ or end with _co() or functions that call qemu_coroutine_yield(), qemu_co_queue_wait(), or any other coroutine_fn.  Add coroutine_fn to the function signature if it is missing.


== Contact persons ==
== Contact persons ==


Some of these tasks are described very briefly and somewhat cryptically. If you're not sure what a task involves, then feel free to ask for clarification on the qemu-devel mailing list, or the contact person for the task (if the task has been marked with a contact):
For tasks above marked with a "(contact: foo)" point of contact, these are those peoples' names, IRC nicks, and email addresses to get in contact with them.


* THH: Thomas Huth (mail: thuth AT redhat.com -- IRC: th_huth)
* eblake: Eric Blake (mail: eblake AT redhat.com -- IRC: eblake)
* eblake: Eric Blake (mail: eblake AT redhat.com -- IRC: eblake)
* jsnow: John Snow (mail: jsnow AT redhat.com -- IRC: jsnow)

Latest revision as of 12:59, 9 April 2024

This list is in the process of being re-evaluated and migrated to the QEMU issue tracker using the Bite Sized issue label.

For QEMU maintainers: Please add your new suggestions to the issue tracker instead, and add the Bite Sized label. Please migrate any existing still relevant ideas to the issue tracker and remove them from this page afterward.

For new contributors: Before starting on one of the tasks on this page, you should check the mailing list archives to ensure no one else has recently submitted similar cleanups for the same task. If nobody has, and the task appears valid, please reach out on the QEMU development mailing list and let us know you'd like to start working on the issue. Please CC: John Snow <jsnow AT redhat.com> when doing so, they'll help get you assigned a GitLab issue and find the right points of contact.

For tasks on the issue tracker or on this page, patches are still handled by submitting patches to the mailing list and not via Gitlab merge requests. Before submitting a patch to the mailing list, please make sure that you've read and understood the patch submission page.

General Notes

In many cases, items on this page describe tasks that might apply to many files in QEMU's sources. In this case, you shouldn't try to solve the problem for the whole of QEMU all at once. Instead, pick a small part of it, ideally related to what you're interested in, and look only at the file or files relevant to that. (For instance, if you're interested in Arm emulation, look at whether one of the tasks affects an Arm device model source file.) It's likely to be more useful to you if you take a particular part of the codebase, and make various different cleanups to it, thus gradually becoming more familiar with it, better able to test it, and so on, rather than trying to make one cleanup to many different parts of QEMU.

Where there is a gitlab issue for a task, that will usually have more detail than the entry on this page; gitlab issues generally are probably more likely to have been defined in a way that will make them tractable for a first-time contributor.

Some of these tasks are described very briefly and somewhat cryptically. If you're not sure what a task involves, then feel free to ask for clarification on the qemu-devel mailing list, or the contact person for the task (if the task has been marked with a contact).

Gitlab "Bite Sized" Issues

Issues tagged "Bite Sized" on the issue tracker may be good candidates for first contributions. If you're interested in solving one of these problems, please register for a Gitlab account and participate in the discussion on the issue so it will be evident to others that you are engaged in researching and fixing the issue.

The issues may sometimes appear to be cryptic or vague. Don't hesitate to ask for more information if the task is not clear. If there is no obvious point of contact from the issue page itself, please reach out for help on the qemu development mailing list.

API conversion

  • Replace manual qemu_mutex_lock() and qemu_mutex_unlock() calls with QEMU_LOCK_GUARD() where it makes the code easier to read. See ToDo/LockGuards for details.
  • Look for uses of malloc, and convert them to g_new or similar. See the fuller writeup in the issue on the bug tracker for more information and a list of the remaining places that need conversion (and the places that don't need it).
  • Replace calls to functions named cpu_physical_memory_* with address_space_*.
  • Replace calls to object_child_foreach() with object_child_foreach_recursive() when applicable: nvdimm_device_list, nmi_monitor_handle, find_sysbus_device, pc_dimm_slot2bitmap, build_dimm_list.
  • The ToDo/CodeTransitions page tracks ongoing internal QEMU API transitions. Most are not trivial but it's a good source of ideas, and some items should be doable for newcomers, too.
  • QSIMPLEQ_REMOVE and QSLIST_REMOVE are inefficient. Check if they could be replaced by QSIMPLEQ_REMOVE_HEAD and QSLIST_REMOVE_HEAD; if not, use a QTAILQ or QLIST respectively.

Code Modernization

  • Convert routines with multiple goto exit-paths to use g_autoptr/g_autofree to handle clean-up and allow direct returns
  • Replace common idioms like if (s->len > 0) { g_string_append(s, ", "); } g_string_append(s, "foo") with common helper function
  • Replace hand-coded uri_string_escape/uri_string_unescape with glib equivalents, for bonus points unify open-coded to/from hex routines with the gdbstub equivilents

Error checking

  • Use qemu_strtol/qemu_strtoul/qemu_strtoll/qemu_strtoull more. (contact: eblake)

Compiler-driven cleanups

  • Use of -Wframe-larger-than=4096 can prevent the use of potential security flaws caused by stack overflows made possible with over-large stack allocations.
  • The following functions have very large stack frames (as obtained with -Wstack-usage=16383), mostly due to huge arrays. Make the stack array smaller and allocate on the heap in the rare case that the data does not fit in the small array:
hw/dma/xilinx_axidma.c               stream_process_mem2s             16480 bytes
hw/net/virtio-net.c                  virtio_net_receive               16544 bytes
net/tap.c                            net_init_tap                     16752 bytes
hw/display/vmware_vga.c              vmsvga_fifo_run                  20688 bytes
hw/virtio/virtio.c                   virtqueue_pop                    24768 bytes
hw/net/virtio-net.c                  virtio_net_flush_tx              32928 bytes
hw/virtio/virtio.c                   qemu_get_virtqueue_element       49216 bytes
hw/virtio/virtio.c                   qemu_put_virtqueue_element       49216 bytes
hw/net/opencores_eth.c               open_eth_start_xmit              65664 bytes
hw/arm/nseries.c                     n8x0_init                        65728 bytes
net/net.c                            nc_sendv_compat                  69680 bytes
net/socket.c                         net_socket_send                  69712 bytes

Note that this list is likely out of date. If you want to work on this you should start by identifying some functions worth looking at by building QEMU yourself with --extra-cflags=-Wstack-usage=16383 --disable-werror . Then you can capture the output of the compile process (e.g. with make -C build -j8 2>&1 | tee stack-usage.log) and look for the warnings in the log file. Come and talk to us on the qemu-devel list about this before putting much work into it -- there are quite a lot of functions with large or even theoretically unbounded stack usage, but not all of them are in places in the code where it's important.

Tracing

  • Add tracepoints. All functions that are named something_helper, and all functions mentioned in MemoryRegionOps are good candidates.
  • Convert DPRINTF() calls to tracepoints (see https://gitlab.com/qemu-project/qemu/-/issues/1827 in the bug tracker for more details)

Bitrot prevention

  • Files with conditional debug statements should ensure that the printf is always compiled, and merely hidden behind if (0) when not debugging, rather than #ifdef'd out. This prevents bitrot of the format string of the debug statement. See this (commit c691320faa6) for an example. Or, go one step further and convert the debug statements to tracepoints. For more detail on tracepoint conversion, see the issue in the bug tracker: https://gitlab.com/qemu-project/qemu/-/issues/1827 (contact: eblake)

Functions that should be static

  • For example: vga_sync_dirty_bitmap, WC_CONFIG_STRING, WC_FULL_CONFIG_STRING, WC_MODEL_STRING, timer_put, vfio_region_ops, vfio_reset_handler, cpu_gen_init, monitor_read_bdrv_key_start, pdu_marshal, pdu_unmarshal, qcrypto_hmac_alg_map (crypto/hmap-nettle.c), spapr_tce_set_need_vfio, virtqueue_map, vnc_disconnect_finish, vnc_display_init, gicv3_full_update_noirqset, cpu_disable_ticks, cpu_enable_ticks, qemu_thread_exit (actually unused in thread-posix.c), qemu_egl_init_dpy_mesa, monitor_defs (3 occurrences), apic_deliver_irq, pcie_host_mmcfg_map, pcie_host_mmcfg_unmap
  • tracetool-generated arrays (e.g. hw_mem_trace_events in the generated file hw/mem/trace.c) should be static.
  • The property types defined in hw/core/qdev-properties-system.c should be moved to other directories (e.g. hw/net for network-related property types). After doing this, some functions probably could become static, too.

Contact persons

For tasks above marked with a "(contact: foo)" point of contact, these are those peoples' names, IRC nicks, and email addresses to get in contact with them.

  • eblake: Eric Blake (mail: eblake AT redhat.com -- IRC: eblake)
  • jsnow: John Snow (mail: jsnow AT redhat.com -- IRC: jsnow)
Retrieved from "https://wiki.qemu.org/index.php?title=Contribute/BiteSizedTasks&oldid=11717"