| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Linus Torvalds (pre-git) | 1496 | 87.54% | 11 | 47.83% |
| Al Viro | 204 | 11.94% | 6 | 26.09% |
| Randy Dunlap | 3 | 0.18% | 1 | 4.35% |
| Ivan Kokshaysky | 2 | 0.12% | 1 | 4.35% |
| Simon Arlott | 1 | 0.06% | 1 | 4.35% |
| Mathieu Desnoyers | 1 | 0.06% | 1 | 4.35% |
| Linus Torvalds | 1 | 0.06% | 1 | 4.35% |
| Greg Kroah-Hartman | 1 | 0.06% | 1 | 4.35% |
| Total | 1709 | 23 |
// SPDX-License-Identifier: GPL-2.0 /* * csum_partial_copy - do IP checksumming and copy * * (C) Copyright 1996 Linus Torvalds * accelerated versions (and 21264 assembly versions ) contributed by * Rick Gorton <rick.gorton@alpha-processor.com> * * Don't look at this too closely - you'll go mad. The things * we do for performance.. */ #include <linux/types.h> #include <linux/string.h> #include <linux/uaccess.h> #include <net/checksum.h> #define ldq_u(x,y) \ __asm__ __volatile__("ldq_u %0,%1":"=r" (x):"m" (*(const unsigned long *)(y))) #define stq_u(x,y) \ __asm__ __volatile__("stq_u %1,%0":"=m" (*(unsigned long *)(y)):"r" (x)) #define extql(x,y,z) \ __asm__ __volatile__("extql %1,%2,%0":"=r" (z):"r" (x),"r" (y)) #define extqh(x,y,z) \ __asm__ __volatile__("extqh %1,%2,%0":"=r" (z):"r" (x),"r" (y)) #define mskql(x,y,z) \ __asm__ __volatile__("mskql %1,%2,%0":"=r" (z):"r" (x),"r" (y)) #define mskqh(x,y,z) \ __asm__ __volatile__("mskqh %1,%2,%0":"=r" (z):"r" (x),"r" (y)) #define insql(x,y,z) \ __asm__ __volatile__("insql %1,%2,%0":"=r" (z):"r" (x),"r" (y)) #define insqh(x,y,z) \ __asm__ __volatile__("insqh %1,%2,%0":"=r" (z):"r" (x),"r" (y)) #define __get_word(insn,x,ptr) \ ({ \ long __guu_err; \ __asm__ __volatile__( \ "1: "#insn" %0,%2\n" \ "2:\n" \ EXC(1b,2b,%0,%1) \ : "=r"(x), "=r"(__guu_err) \ : "m"(__m(ptr)), "1"(0)); \ __guu_err; \ }) static inline unsigned short from64to16(unsigned long x) { /* Using extract instructions is a bit more efficient than the original shift/bitmask version. */ union { unsigned long ul; unsigned int ui[2]; unsigned short us[4]; } in_v, tmp_v, out_v; in_v.ul = x; tmp_v.ul = (unsigned long) in_v.ui[0] + (unsigned long) in_v.ui[1]; /* Since the bits of tmp_v.sh[3] are going to always be zero, we don't have to bother to add that in. */ out_v.ul = (unsigned long) tmp_v.us[0] + (unsigned long) tmp_v.us[1] + (unsigned long) tmp_v.us[2]; /* Similarly, out_v.us[2] is always zero for the final add. */ return out_v.us[0] + out_v.us[1]; } /* * Ok. This isn't fun, but this is the EASY case. */ static inline unsigned long csum_partial_cfu_aligned(const unsigned long __user *src, unsigned long *dst, long len) { unsigned long checksum = ~0U; unsigned long carry = 0; while (len >= 0) { unsigned long word; if (__get_word(ldq, word, src)) return 0; checksum += carry; src++; checksum += word; len -= 8; carry = checksum < word; *dst = word; dst++; } len += 8; checksum += carry; if (len) { unsigned long word, tmp; if (__get_word(ldq, word, src)) return 0; tmp = *dst; mskql(word, len, word); checksum += word; mskqh(tmp, len, tmp); carry = checksum < word; *dst = word | tmp; checksum += carry; } return checksum; } /* * This is even less fun, but this is still reasonably * easy. */ static inline unsigned long csum_partial_cfu_dest_aligned(const unsigned long __user *src, unsigned long *dst, unsigned long soff, long len) { unsigned long first; unsigned long word, carry; unsigned long lastsrc = 7+len+(unsigned long)src; unsigned long checksum = ~0U; if (__get_word(ldq_u, first,src)) return 0; carry = 0; while (len >= 0) { unsigned long second; if (__get_word(ldq_u, second, src+1)) return 0; extql(first, soff, word); len -= 8; src++; extqh(second, soff, first); checksum += carry; word |= first; first = second; checksum += word; *dst = word; dst++; carry = checksum < word; } len += 8; checksum += carry; if (len) { unsigned long tmp; unsigned long second; if (__get_word(ldq_u, second, lastsrc)) return 0; tmp = *dst; extql(first, soff, word); extqh(second, soff, first); word |= first; mskql(word, len, word); checksum += word; mskqh(tmp, len, tmp); carry = checksum < word; *dst = word | tmp; checksum += carry; } return checksum; } /* * This is slightly less fun than the above.. */ static inline unsigned long csum_partial_cfu_src_aligned(const unsigned long __user *src, unsigned long *dst, unsigned long doff, long len, unsigned long partial_dest) { unsigned long carry = 0; unsigned long word; unsigned long second_dest; unsigned long checksum = ~0U; mskql(partial_dest, doff, partial_dest); while (len >= 0) { if (__get_word(ldq, word, src)) return 0; len -= 8; insql(word, doff, second_dest); checksum += carry; stq_u(partial_dest | second_dest, dst); src++; checksum += word; insqh(word, doff, partial_dest); carry = checksum < word; dst++; } len += 8; if (len) { checksum += carry; if (__get_word(ldq, word, src)) return 0; mskql(word, len, word); len -= 8; checksum += word; insql(word, doff, second_dest); len += doff; carry = checksum < word; partial_dest |= second_dest; if (len >= 0) { stq_u(partial_dest, dst); if (!len) goto out; dst++; insqh(word, doff, partial_dest); } doff = len; } ldq_u(second_dest, dst); mskqh(second_dest, doff, second_dest); stq_u(partial_dest | second_dest, dst); out: checksum += carry; return checksum; } /* * This is so totally un-fun that it's frightening. Don't * look at this too closely, you'll go blind. */ static inline unsigned long csum_partial_cfu_unaligned(const unsigned long __user * src, unsigned long * dst, unsigned long soff, unsigned long doff, long len, unsigned long partial_dest) { unsigned long carry = 0; unsigned long first; unsigned long lastsrc; unsigned long checksum = ~0U; if (__get_word(ldq_u, first, src)) return 0; lastsrc = 7+len+(unsigned long)src; mskql(partial_dest, doff, partial_dest); while (len >= 0) { unsigned long second, word; unsigned long second_dest; if (__get_word(ldq_u, second, src+1)) return 0; extql(first, soff, word); checksum += carry; len -= 8; extqh(second, soff, first); src++; word |= first; first = second; insql(word, doff, second_dest); checksum += word; stq_u(partial_dest | second_dest, dst); carry = checksum < word; insqh(word, doff, partial_dest); dst++; } len += doff; checksum += carry; if (len >= 0) { unsigned long second, word; unsigned long second_dest; if (__get_word(ldq_u, second, lastsrc)) return 0; extql(first, soff, word); extqh(second, soff, first); word |= first; first = second; mskql(word, len-doff, word); checksum += word; insql(word, doff, second_dest); carry = checksum < word; stq_u(partial_dest | second_dest, dst); if (len) { ldq_u(second_dest, dst+1); insqh(word, doff, partial_dest); mskqh(second_dest, len, second_dest); stq_u(partial_dest | second_dest, dst+1); } checksum += carry; } else { unsigned long second, word; unsigned long second_dest; if (__get_word(ldq_u, second, lastsrc)) return 0; extql(first, soff, word); extqh(second, soff, first); word |= first; ldq_u(second_dest, dst); mskql(word, len-doff, word); checksum += word; mskqh(second_dest, len, second_dest); carry = checksum < word; insql(word, doff, word); stq_u(partial_dest | word | second_dest, dst); checksum += carry; } return checksum; } static __wsum __csum_and_copy(const void __user *src, void *dst, int len) { unsigned long soff = 7 & (unsigned long) src; unsigned long doff = 7 & (unsigned long) dst; unsigned long checksum; if (!doff) { if (!soff) checksum = csum_partial_cfu_aligned( (const unsigned long __user *) src, (unsigned long *) dst, len-8); else checksum = csum_partial_cfu_dest_aligned( (const unsigned long __user *) src, (unsigned long *) dst, soff, len-8); } else { unsigned long partial_dest; ldq_u(partial_dest, dst); if (!soff) checksum = csum_partial_cfu_src_aligned( (const unsigned long __user *) src, (unsigned long *) dst, doff, len-8, partial_dest); else checksum = csum_partial_cfu_unaligned( (const unsigned long __user *) src, (unsigned long *) dst, soff, doff, len-8, partial_dest); } return (__force __wsum)from64to16 (checksum); } __wsum csum_and_copy_from_user(const void __user *src, void *dst, int len) { if (!access_ok(src, len)) return 0; return __csum_and_copy(src, dst, len); } __wsum csum_partial_copy_nocheck(const void *src, void *dst, int len) { return __csum_and_copy((__force const void __user *)src, dst, len); } EXPORT_SYMBOL(csum_partial_copy_nocheck);
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1