lib/libspl/include/os/linux/sys/byteorder.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*      Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T     */
  28 /*        All Rights Reserved   */
  29
  30 /*
  31  * University Copyright- Copyright (c) 1982, 1986, 1988
  32  * The Regents of the University of California
  33  * All Rights Reserved
  34  *
  35  * University Acknowledgment- Portions of this document are derived from
  36  * software developed by the University of California, Berkeley, and its
  37  * contributors.
  38  */
  39
  40 #ifndef _SYS_BYTEORDER_H
  41 #define _SYS_BYTEORDER_H
  42
  43 #if defined(__GNUC__) && defined(_ASM_INLINES) && \
  44         (defined(__i386) || defined(__amd64))
  45 #include <asm/byteorder.h>
  46 #endif
  47
  48 #include <sys/isa_defs.h>
  49 #include <sys/int_types.h>
  50
  51 #ifdef  __cplusplus
  52 extern "C" {
  53 #endif
  54
  55 /*
  56  * macros for conversion between host and (internet) network byte order
  57  */
  58
  59 #if defined(_ZFS_BIG_ENDIAN) && !defined(ntohl) && !defined(__lint)
  60 /* big-endian */
  61 #define ntohl(x)        (x)
  62 #define ntohs(x)        (x)
  63 #define htonl(x)        (x)
  64 #define htons(x)        (x)
  65
  66 #elif !defined(ntohl) /* little-endian */
  67
  68 #ifndef _IN_PORT_T
  69 #define _IN_PORT_T
  70 typedef uint16_t in_port_t;
  71 #endif
  72
  73 #ifndef _IN_ADDR_T
  74 #define _IN_ADDR_T
  75 typedef uint32_t in_addr_t;
  76 #endif
  77
  78 #if !defined(_XPG4_2) || defined(__EXTENSIONS__) || defined(_XPG5)
  79 extern  uint32_t htonl(uint32_t);
  80 extern  uint16_t htons(uint16_t);
  81 extern  uint32_t ntohl(uint32_t);
  82 extern  uint16_t ntohs(uint16_t);
  83 #else
  84 extern  in_addr_t htonl(in_addr_t);
  85 extern  in_port_t htons(in_port_t);
  86 extern  in_addr_t ntohl(in_addr_t);
  87 extern  in_port_t ntohs(in_port_t);
  88 #endif  /* !defined(_XPG4_2) || defined(__EXTENSIONS__) || defined(_XPG5) */
  89 #endif
  90
  91 #if !defined(_XPG4_2) || defined(__EXTENSIONS__)
  92
  93 /*
  94  * Macros to reverse byte order
  95  */
  96 #define BSWAP_8(x)      ((x) & 0xff)
  97 #define BSWAP_16(x)     ((BSWAP_8(x) << 8) | BSWAP_8((x) >> 8))
  98 #define BSWAP_32(x)     ((BSWAP_16(x) << 16) | BSWAP_16((x) >> 16))
  99 #define BSWAP_64(x)     ((BSWAP_32(x) << 32) | BSWAP_32((x) >> 32))
 100
 101 #define BMASK_8(x)      ((x) & 0xff)
 102 #define BMASK_16(x)     ((x) & 0xffff)
 103 #define BMASK_32(x)     ((x) & 0xffffffff)
 104 #define BMASK_64(x)     (x)
 105
 106 /*
 107  * Macros to convert from a specific byte order to/from native byte order
 108  */
 109 #ifdef _ZFS_BIG_ENDIAN
 110 #define BE_8(x)         BMASK_8(x)
 111 #define BE_16(x)        BMASK_16(x)
 112 #define BE_32(x)        BMASK_32(x)
 113 #define BE_64(x)        BMASK_64(x)
 114 #define LE_8(x)         BSWAP_8(x)
 115 #define LE_16(x)        BSWAP_16(x)
 116 #define LE_32(x)        BSWAP_32(x)
 117 #define LE_64(x)        BSWAP_64(x)
 118 #else
 119 #define LE_8(x)         BMASK_8(x)
 120 #define LE_16(x)        BMASK_16(x)
 121 #define LE_32(x)        BMASK_32(x)
 122 #define LE_64(x)        BMASK_64(x)
 123 #define BE_8(x)         BSWAP_8(x)
 124 #define BE_16(x)        BSWAP_16(x)
 125 #define BE_32(x)        BSWAP_32(x)
 126 #define BE_64(x)        BSWAP_64(x)
 127 #endif
 128
 129 #ifdef _ZFS_BIG_ENDIAN
 130 static __inline__ uint64_t
 131 htonll(uint64_t n)
 132 {
 133         return (n);
 134 }
 135
 136 static __inline__ uint64_t
 137 ntohll(uint64_t n)
 138 {
 139         return (n);
 140 }
 141 #else
 142 static __inline__ uint64_t
 143 htonll(uint64_t n)
 144 {
 145         return ((((uint64_t)htonl(n)) << 32) + htonl(n >> 32));
 146 }
 147
 148 static __inline__ uint64_t
 149 ntohll(uint64_t n)
 150 {
 151         return ((((uint64_t)ntohl(n)) << 32) + ntohl(n >> 32));
 152 }
 153 #endif
 154
 155 /*
 156  * Macros to read unaligned values from a specific byte order to
 157  * native byte order
 158  */
 159
 160 #define BE_IN8(xa) \
 161         *((uint8_t *)(xa))
 162
 163 #define BE_IN16(xa) \
 164         (((uint16_t)BE_IN8(xa) << 8) | BE_IN8((uint8_t *)(xa)+1))
 165
 166 #define BE_IN32(xa) \
 167         (((uint32_t)BE_IN16(xa) << 16) | BE_IN16((uint8_t *)(xa)+2))
 168
 169 #define BE_IN64(xa) \
 170         (((uint64_t)BE_IN32(xa) << 32) | BE_IN32((uint8_t *)(xa)+4))
 171
 172 #define LE_IN8(xa) \
 173         *((uint8_t *)(xa))
 174
 175 #define LE_IN16(xa) \
 176         (((uint16_t)LE_IN8((uint8_t *)(xa) + 1) << 8) | LE_IN8(xa))
 177
 178 #define LE_IN32(xa) \
 179         (((uint32_t)LE_IN16((uint8_t *)(xa) + 2) << 16) | LE_IN16(xa))
 180
 181 #define LE_IN64(xa) \
 182         (((uint64_t)LE_IN32((uint8_t *)(xa) + 4) << 32) | LE_IN32(xa))
 183
 184 /*
 185  * Macros to write unaligned values from native byte order to a specific byte
 186  * order.
 187  */
 188
 189 #define BE_OUT8(xa, yv) *((uint8_t *)(xa)) = (uint8_t)(yv);
 190
 191 #define BE_OUT16(xa, yv) \
 192         BE_OUT8((uint8_t *)(xa) + 1, yv); \
 193         BE_OUT8((uint8_t *)(xa), (yv) >> 8);
 194
 195 #define BE_OUT32(xa, yv) \
 196         BE_OUT16((uint8_t *)(xa) + 2, yv); \
 197         BE_OUT16((uint8_t *)(xa), (yv) >> 16);
 198
 199 #define BE_OUT64(xa, yv) \
 200         BE_OUT32((uint8_t *)(xa) + 4, yv); \
 201         BE_OUT32((uint8_t *)(xa), (yv) >> 32);
 202
 203 #define LE_OUT8(xa, yv) *((uint8_t *)(xa)) = (uint8_t)(yv);
 204
 205 #define LE_OUT16(xa, yv) \
 206         LE_OUT8((uint8_t *)(xa), yv); \
 207         LE_OUT8((uint8_t *)(xa) + 1, (yv) >> 8);
 208
 209 #define LE_OUT32(xa, yv) \
 210         LE_OUT16((uint8_t *)(xa), yv); \
 211         LE_OUT16((uint8_t *)(xa) + 2, (yv) >> 16);
 212
 213 #define LE_OUT64(xa, yv) \
 214         LE_OUT32((uint8_t *)(xa), yv); \
 215         LE_OUT32((uint8_t *)(xa) + 4, (yv) >> 32);
 216
 217 #endif  /* !defined(_XPG4_2) || defined(__EXTENSIONS__) */
 218
 219 #ifdef  __cplusplus
 220 }
 221 #endif
 222
 223 #endif /* _SYS_BYTEORDER_H */