include/asm-i386/checksum.h

   1 #ifndef _I386_CHECKSUM_H
   2 #define _I386_CHECKSUM_H
   3
   4
   5 /*
   6  * computes the checksum of a memory block at buff, length len,
   7  * and adds in "sum" (32-bit)
   8  *
   9  * returns a 32-bit number suitable for feeding into itself
  10  * or csum_tcpudp_magic
  11  *
  12  * this function must be called with even lengths, except
  13  * for the last fragment, which may be odd
  14  *
  15  * it's best to have buff aligned on a 32-bit boundary
  16  */
  17 unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum);
  18
  19 /*
  20  * the same as csum_partial, but copies from src while it
  21  * checksums, and handles user-space pointer exceptions correctly, when needed.
  22  *
  23  * here even more important to align src and dst on a 32-bit (or even
  24  * better 64-bit) boundary
  25  */
  26
  27 unsigned int csum_partial_copy_generic( const char *src, char *dst, int len, int sum,
  28                                         int *src_err_ptr, int *dst_err_ptr);
  29
  30 extern __inline__
  31 unsigned int csum_partial_copy_nocheck ( const char *src, char *dst,
  32                                         int len, int sum)
  33 {
  34         int *src_err_ptr=NULL, *dst_err_ptr=NULL;
  35
  36         return csum_partial_copy_generic ( src, dst, len, sum, src_err_ptr, dst_err_ptr);
  37 }
  38
  39 extern __inline__
  40 unsigned int csum_partial_copy_from_user ( const char *src, char *dst,
  41                                                 int len, int sum, int *err_ptr)
  42 {
  43         int *dst_err_ptr=NULL;
  44
  45         return csum_partial_copy_generic ( src, dst, len, sum, err_ptr, dst_err_ptr);
  46 }
  47
  48 #if 0
  49
  50 /* Not used at the moment. It is difficult to imagine for what purpose
  51    it can be used :-) Please, do not forget to verify_area before it --ANK
  52  */
  53
  54 /*
  55  * This combination is currently not used, but possible:
  56  */
  57
  58 extern __inline__
  59 unsigned int csum_partial_copy_to_user ( const char *src, char *dst,
  60                                         int len, int sum, int *err_ptr)
  61 {
  62         int *src_err_ptr=NULL;
  63
  64         return csum_partial_copy_generic ( src, dst, len, sum, src_err_ptr, err_ptr);
  65 }
  66 #endif
  67
  68 /*
  69  * These are the old (and unsafe) way of doing checksums, a warning message will be
  70  * printed if they are used and an exeption occurs.
  71  *
  72  * these functions should go away after some time.
  73  */
  74
  75 #define csum_partial_copy_fromuser csum_partial_copy
  76 unsigned int csum_partial_copy( const char *src, char *dst, int len, int sum);
  77
  78 /*
  79  *      This is a version of ip_compute_csum() optimized for IP headers,
  80  *      which always checksum on 4 octet boundaries.
  81  *
  82  *      By Jorge Cwik <jorge@laser.satlink.net>, adapted for linux by
  83  *      Arnt Gulbrandsen.
  84  */
  85 static inline unsigned short ip_fast_csum(unsigned char * iph,
  86                                           unsigned int ihl) {
  87         unsigned int sum;
  88
  89         __asm__ __volatile__("
  90             movl (%1), %0
  91             subl $4, %2
  92             jbe 2f
  93             addl 4(%1), %0
  94             adcl 8(%1), %0
  95             adcl 12(%1), %0
  96 1:          adcl 16(%1), %0
  97             lea 4(%1), %1
  98             decl %2
  99             jne 1b
 100             adcl $0, %0
 101             movl %0, %2
 102             shrl $16, %0
 103             addw %w2, %w0
 104             adcl $0, %0
 105             notl %0
 106 2:
 107             "
 108         /* Since the input registers which are loaded with iph and ipl
 109            are modified, we must also specify them as outputs, or gcc
 110            will assume they contain their original values. */
 111         : "=r" (sum), "=r" (iph), "=r" (ihl)
 112         : "1" (iph), "2" (ihl));
 113         return(sum);
 114 }
 115
 116 /*
 117  *      Fold a partial checksum
 118  */
 119
 120 static inline unsigned int csum_fold(unsigned int sum)
 121 {
 122         __asm__("
 123                 addl %1, %0
 124                 adcl $0xffff, %0
 125                 "
 126                 : "=r" (sum)
 127                 : "r" (sum << 16), "0" (sum & 0xffff0000)
 128         );
 129         return (~sum) >> 16;
 130 }
 131
 132 static inline unsigned long csum_tcpudp_nofold(unsigned long saddr,
 133                                                    unsigned long daddr,
 134                                                    unsigned short len,
 135                                                    unsigned short proto,
 136                                                    unsigned int sum)
 137 {
 138     __asm__("
 139         addl %1, %0
 140         adcl %2, %0
 141         adcl %3, %0
 142         adcl $0, %0
 143         "
 144         : "=r" (sum)
 145         : "g" (daddr), "g"(saddr), "g"((ntohs(len)<<16)+proto*256), "0"(sum));
 146     return sum;
 147 }
 148
 149 /*
 150  * computes the checksum of the TCP/UDP pseudo-header
 151  * returns a 16-bit checksum, already complemented
 152  */
 153 static inline unsigned short int csum_tcpudp_magic(unsigned long saddr,
 154                                                    unsigned long daddr,
 155                                                    unsigned short len,
 156                                                    unsigned short proto,
 157                                                    unsigned int sum)
 158 {
 159         return csum_fold(csum_tcpudp_nofold(saddr,daddr,len,proto,sum));
 160 }
 161
 162 /*
 163  * this routine is used for miscellaneous IP-like checksums, mainly
 164  * in icmp.c
 165  */
 166
 167 static inline unsigned short ip_compute_csum(unsigned char * buff, int len) {
 168     return csum_fold (csum_partial(buff, len, 0));
 169 }
 170
 171 #define _HAVE_ARCH_IPV6_CSUM
 172 static __inline__ unsigned short int csum_ipv6_magic(struct in6_addr *saddr,
 173                                                      struct in6_addr *daddr,
 174                                                      __u16 len,
 175                                                      unsigned short proto,
 176                                                      unsigned int sum)
 177 {
 178         __asm__("
 179                 addl 0(%1), %0
 180                 adcl 4(%1), %0
 181                 adcl 8(%1), %0
 182                 adcl 12(%1), %0
 183                 adcl 0(%2), %0
 184                 adcl 4(%2), %0
 185                 adcl 8(%2), %0
 186                 adcl 12(%2), %0
 187                 adcl %3, %0
 188                 adcl %4, %0
 189                 adcl $0, %0
 190                 "
 191                 : "=&r" (sum)
 192                 : "r" (saddr), "r" (daddr),
 193                   "r"(htonl((__u32) (len))), "r"(htonl(proto)), "0"(sum));
 194
 195         return csum_fold(sum);
 196 }
 197
 198 /*
 199  *      Copy and checksum to user
 200  */
 201 #define HAVE_CSUM_COPY_USER
 202 static __inline__ unsigned int csum_and_copy_to_user (const char *src, char *dst,
 203                                     int len, int sum, int *err_ptr)
 204 {
 205         int *src_err_ptr=NULL;
 206
 207         if (verify_area(VERIFY_WRITE, dst, len) == 0)
 208                 return csum_partial_copy_generic(src, dst, len, sum, src_err_ptr, err_ptr);
 209
 210         if (len)
 211                 *err_ptr = -EFAULT;
 212
 213         return sum;
 214 }
 215
 216 #endif