errno

Global error variable

Synopsis:

#include <errno.h>

extern int errno;

char * const sys_errlist[];
int sys_nerr;

Library:

libc

Use the -l c option to qcc to link against this library. This library is usually included automatically.

Description:

The errno variable is set to certain error values by many functions whenever an error has occurred.

---

You can't assume that the value of errno is valid unless the function that you've called indicates that an error has occurred. The runtime library never resets errno to 0. The documentation for a function might list special meanings for certain values of errno, but this doesn't mean that these are the only values that the function might set.

---

The errno variable may be implemented as a macro, but you can always examine or set it as if it were a simple integer variable.

---

Each thread in a multi-threaded program has its own error value in its thread local storage. No matter which thread you're in, you can simply refer to errno — it's defined in such a way that it refers to the correct variable for the thread. For more information, see “Local storage for private data” in the documentation for ThreadCreate().

---

The following variables are also defined in <errno.h>:

sys_errlist

An array of error messages corresponding to errno.

sys_nerr

The number of entries in the sys_errlist array.

The values for errno include at least the following values:

Changes to EALREADY

POSIX requires that the error numbers in <errno.h> have unique values. In order to satisfy this requirement, we're changing EALREADY so that it no longer has the same value as EBUSY.

This change could cause incompatibility problems because code that currently uses EALREADY has been compiled to use the old value. In order to allow applications to safely make the transition to the new value, we've modified <errno.h> to define a number of new symbolic values:

EALREADY_OLD

The old value (16).

EALREADY_NEW

The new value (237).

EALREADY_DYNAMIC

A value that you can configure at runtime. This is a variable in libc that's set to either the old or new value, based on a system-wide configuration parameter.

In QNX Neutrino 6.4.0, EALREADY is defined as EALREADY_OLD, so that programs by default are compatible with existing binaries. EALREADY will be changed in a future release to EALREADY_NEW. In order to support a safe transition to the new value, you should modify your code as follows:

• If your code checks for EALREADY return codes, recode it to be like this:

  #if defined(EALREADY_NEW) && defined(EALREADY_OLD)
      if (error == EALREADY_NEW || error == EALREADY_OLD) {
          // deal with EALREADY error cases
      }
  #else
      if (error == EALREADY) {
          // deal with EALREADY error cases
      }
  #endif
    

  This will ensure that the code handles EALREADY error cases from any API that returns either the old or new value.

• If your code returns an EALREADY error, modify it to return EALREADY_DYNAMIC instead. In many cases, you can do this by adding -DEALREADY=EALREADY_DYNAMIC to the compiler flags.

You can use the -e option to procnto to specify the value of EALREADY_DYNAMIC:

-eo

Use the old value, which is the same as that of EBUSY.

-en

Use the POSIX-compliant value.

Examples:

/*
 *  The following program makes an illegal call
 *  to the write() function, then prints the
 *  value held in errno.
 */
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>

int main( void )
{
    int errvalue;

    errno = EOK;
    write( -1, "hello, world\n",
           strlen( "hello, world\n" ) );
    errvalue = errno;
    printf( "The error generated was %d\n", errvalue );
    printf( "That means: %s\n", strerror( errvalue ) );
}

Classification:

ANSI, POSIX 1003.1

See also:

h_errno, perror(), stderr, strerror()