CACHEFLUSH(2)             (2020-12-21)              CACHEFLUSH(2)

          cacheflush - flush contents of instruction and/or data cache

          #include <asm/cachectl.h>

          int cacheflush(char *addr, int nbytes, int cache

          Note: On some architectures, there is no glibc wrapper for
          this system call; see NOTES.

          cacheflush() flushes the contents of the indicated cache(s)
          for the user addresses in the range addr to (addr+nbytes-1).
          cache may be one of:

               Flush the instruction cache.

               Write back to memory and invalidate the affected valid
               cache lines.

               Same as (ICACHE|DCACHE).

          cacheflush() returns 0 on success or -1 on error.  If errors
          are detected, errno will indicate the error.

               Some or all of the address range addr to (addr+nbytes-
               1) is not accessible.

               cache is not one of ICACHE, DCACHE, or BCACHE (but see

          Historically, this system call was available on all MIPS
          UNIX variants including RISC/os, IRIX, Ultrix, NetBSD,
          OpenBSD, and FreeBSD (and also on some non-UNIX MIPS operat-
          ing systems), so that the existence of this call in MIPS
          operating systems is a de-facto standard.

          cacheflush() should not be used in programs intended to be
          portable.  On Linux, this call first appeared on the MIPS
          architecture, but nowadays, Linux provides a cacheflush()

     Page 1                        Linux             (printed 5/22/22)

     CACHEFLUSH(2)             (2020-12-21)              CACHEFLUSH(2)

          system call on some other architectures, but with different

        Architecture-specific variants
          Glibc provides a wrapper for this system call, with the pro-
          totype shown in SYNOPSIS, for the following architectures:
          ARC, CSKY, MIPS, and NIOS2.

          On some other architectures, Linux provides this system
          call, with different arguments:

               int cacheflush(unsigned long addr, int scope, int cache
                              unsigned long len);

               int cacheflush(unsigned long addr, unsigned long len, int op

               int cacheflush(unsigned int start, unsigned int end, int cache

          On the above architectures, glibc does not provide a wrapper
          for this system call; call it using syscall(2).

        GCC alternative
          Unless you need the finer grained control that this system
          call provides, you probably want to use the GCC built-in
          function __builtin___clear_cache(), which provides a port-
          able interface across platforms supported by GCC and compat-
          ible compilers:

              void __builtin___clear_cache(void *begin, void *end);

          On platforms that don't require instruction cache flushes,
          __builtin___clear_cache() has no effect.

          Note: On some GCC-compatible compilers, the prototype for
          this built-in function uses char * instead of void * for the

          Linux kernels older than version 2.6.11 ignore the addr and
          nbytes arguments, making this function fairly expensive.
          Therefore, the whole cache is always flushed.

          This function always behaves as if BCACHE has been passed
          for the cache argument and does not do any error checking on
          the cache argument.

          This page is part of release 5.10 of the Linux man-pages

     Page 2                        Linux             (printed 5/22/22)

     CACHEFLUSH(2)             (2020-12-21)              CACHEFLUSH(2)

          project.  A description of the project, information about
          reporting bugs, and the latest version of this page, can be
          found at

     Page 3                        Linux             (printed 5/22/22)