Return to checksum.h CVS log

Up to [GnuMach] / Gnu-Mach / linux / src / include / asm-i386

Annotation of Gnu-Mach/linux/src/include/asm-i386/checksum.h, revision 1.1.1.1

1.1       root        1: #ifndef _I386_CHECKSUM_H
                      2: #define _I386_CHECKSUM_H
                      3: 
                      4: /*
                      5:  * computes the checksum of a memory block at buff, length len,
                      6:  * and adds in "sum" (32-bit)
                      7:  *
                      8:  * returns a 32-bit number suitable for feeding into itself
                      9:  * or csum_tcpudp_magic
                     10:  *
                     11:  * this function must be called with even lengths, except
                     12:  * for the last fragment, which may be odd
                     13:  *
                     14:  * it's best to have buff aligned on a 32-bit boundary
                     15:  */
                     16: unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum);
                     17: 
                     18: /*
                     19:  * the same as csum_partial, but copies from src while it
                     20:  * checksums
                     21:  *
                     22:  * here even more important to align src and dst on a 32-bit (or even
                     23:  * better 64-bit) boundary
                     24:  */
                     25: 
                     26: unsigned int csum_partial_copy( const char *src, char *dst, int len, int sum);
                     27: 
                     28: 
                     29: /*
                     30:  * the same as csum_partial_copy, but copies from user space.
                     31:  *
                     32:  * here even more important to align src and dst on a 32-bit (or even
                     33:  * better 64-bit) boundary
                     34:  */
                     35: 
                     36: unsigned int csum_partial_copy_fromuser(const char *src, char *dst, int len, int sum);
                     37: 
                     38: /*
                     39:  *     This is a version of ip_compute_csum() optimized for IP headers,
                     40:  *     which always checksum on 4 octet boundaries.
                     41:  *
                     42:  *     By Jorge Cwik <[email protected]>, adapted for linux by
                     43:  *     Arnt Gulbrandsen.
                     44:  */
                     45: static inline unsigned short ip_fast_csum(unsigned char * iph,
                     46:                                          unsigned int ihl) {
                     47:        unsigned int sum;
                     48: 
                     49:        __asm__ __volatile__("
                     50:            movl (%1), %0
                     51:            subl $4, %2
                     52:            jbe 2f
                     53:            addl 4(%1), %0
                     54:            adcl 8(%1), %0
                     55:            adcl 12(%1), %0
                     56: 1:         adcl 16(%1), %0
                     57:            lea 4(%1), %1
                     58:            decl %2
                     59:            jne 1b
                     60:            adcl $0, %0
                     61:            movl %0, %2
                     62:            shrl $16, %0
                     63:            addw %w2, %w0
                     64:            adcl $0, %0
                     65:            notl %0
                     66: 2:
                     67:            "
                     68:        /* Since the input registers which are loaded with iph and ipl
                     69:           are modified, we must also specify them as outputs, or gcc
                     70:           will assume they contain their original values. */
                     71:        : "=r" (sum), "=r" (iph), "=r" (ihl)
                     72:        : "1" (iph), "2" (ihl));
                     73:        return(sum);
                     74: }
                     75: 
                     76: /*
                     77:  *     Fold a partial checksum
                     78:  */
                     79: 
                     80: static inline unsigned int csum_fold(unsigned int sum)
                     81: {
                     82:        __asm__("
                     83:                addl %1, %0
                     84:                adcl $0xffff, %0
                     85:                "
                     86:                : "=r" (sum)
                     87:                : "r" (sum << 16), "0" (sum & 0xffff0000)
                     88:        );
                     89:        return (~sum) >> 16;
                     90: }
                     91:  
                     92: /*
                     93:  * computes the checksum of the TCP/UDP pseudo-header
                     94:  * returns a 16-bit checksum, already complemented
                     95:  */
                     96: 
                     97: static inline unsigned short int csum_tcpudp_magic(unsigned long saddr,
                     98:                                                   unsigned long daddr,
                     99:                                                   unsigned short len,
                    100:                                                   unsigned short proto,
                    101:                                                   unsigned int sum) {
                    102:     __asm__("
                    103:        addl %1, %0
                    104:        adcl %2, %0
                    105:        adcl %3, %0
                    106:        adcl $0, %0
                    107:        "
                    108:        : "=r" (sum)
                    109:        : "g" (daddr), "g"(saddr), "g"((ntohs(len)<<16)+proto*256), "0"(sum));
                    110:        return csum_fold(sum);
                    111: }
                    112: /*
                    113:  * this routine is used for miscellaneous IP-like checksums, mainly
                    114:  * in icmp.c
                    115:  */
                    116: 
                    117: static inline unsigned short ip_compute_csum(unsigned char * buff, int len) {
                    118:     return csum_fold (csum_partial(buff, len, 0));
                    119: }
                    120: 
                    121: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.