/*
* Do a strncpy, return length of string without final '\0'.
* 'count' is the user-supplied count (return 'count' if we
* hit it), 'max' is the address space maximum (and we return
* -EFAULT if we hit it).
*/
static inline long do_strncpy_from_user(char *dst, const char __user *src, long count, unsigned long max)
{
static const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
long res = 0;
/*
* Truncate 'max' to the user-specified limit, so that
* we only have one limit we need to check in the loop
*/
if (max > count)
max = count;
if (IS_UNALIGNED(src, dst))
goto byte_at_a_time;
while (max >= sizeof(unsigned long)) {
unsigned long c, data;
/* Fall back to byte-at-a-time if we get a page fault */
if (unlikely(__get_user(c,(unsigned long __user *)(src+res))))
break;
*(unsigned long *)(dst+res) = c;
if (has_zero(c, &data, &constants)) {
data = prep_zero_mask(c, data, &constants);
data = create_zero_mask(data);
return res + find_zero(data);
}
res += sizeof(unsigned long);
max -= sizeof(unsigned long);
}
byte_at_a_time:
while (max) {
char c;
if (unlikely(__get_user(c,src+res)))
return -EFAULT;
dst[res] = c;
if (!c)
return res;
res++;
max--;
}
/*
* Uhhuh. We hit 'max'. But was that the user-specified maximum
* too? If so, that's ok - we got as much as the user asked for.
*/
if (res >= count)
return res;
/*
* Nope: we hit the address space limit, and we still had more
* characters the caller would have wanted. That's an EFAULT.
*/
return -EFAULT;
}
static __inline__ void *
__memchr(const unsigned char * m,unsigned char val,size_t len)
{
void * result = NULL;
/* The setup below is intended to speed up searching in larger
* memory blocks. This can be very elaborate and should not be
* done unless a payoff can be expected.
*/
if(len > 4 * sizeof(long))
{
/* Try to align the memory block to an even address. */
if(IS_UNALIGNED(m))
{
len--;
if((*m) == val)
{
result = (void *)m;
goto out;
}
m++;
}
/* Try to align the memory block to an address which is
* a multiple of a long word.
*/
if(len >= sizeof(short) && IS_SHORT_ALIGNED(m))
{
len--;
if((*m) == val)
{
result = (void *)m;
goto out;
}
m++;
len--;
if((*m) == val)
{
result = (void *)m;
goto out;
}
m++;
}
/* If the memory block is aligned to an address from which
* data can be read one long word at a time, perform the
* search in this manner.
*/
if(len >= sizeof(long) && IS_LONG_ALIGNED(m))
{
const unsigned long * _m = (const unsigned long *)m;
unsigned long _val = val;
unsigned long x;
/* Build a long word which contains the byte value to
* find, repeated four times.
*/
_val |= (_val << 8);
_val |= (_val << 16);
do
{
/* Technically, what we want to achieve is to look
* at a single long word and be able to tell whether
* it contains the value we are looking for in one
* of the octets which it consists of. This is
* achieved by an XOR operation which sets those
* octets to zero which match the search value. The
* result of this operation is then tested to see
* whether it contains any zero octets.
*/
x = (*_m) ^ _val;
if(LONG_CONTAINS_ZERO_OCTET(x))
{
/* We got what we wanted. Now figure out which byte
* would match the value we were looking for.
*/
m = (const unsigned char *)_m;
goto out;
}
_m++;
len -= sizeof(long);
}
while(len >= sizeof(long));
m = (const unsigned char *)_m;
}
}
out:
/* If there are bytes left in need of comparison, take
* care of them here. This also includes 'aborted'
* comparison attempts from above.
*/
while(len-- > 0)
{
if((*m) == val)
{
result = (void *)m;
break;
}
m++;
}
return(result);
}
INLINE STATIC VOID
__memcpy(unsigned char * to,unsigned char * from,size_t len)
{
/* The setup below is intended to speed up copying larger
* memory blocks. This can be very elaborate and should not be
* done unless a payoff can be expected.
*/
if(len > 4 * sizeof(long))
{
/* Try to align both source and destination to an even address. */
if(IS_UNALIGNED(to) && IS_UNALIGNED(from))
{
(*to++) = (*from++);
len--;
}
/* Try to align both source and destination to addresses which are
* multiples of four.
*/
if(len >= sizeof(short) && IS_SHORT_ALIGNED(to) && IS_SHORT_ALIGNED(from))
{
(*to++) = (*from++);
(*to++) = (*from++);
len -= sizeof(short);
}
/* If both source and destination are aligned to addresses which are
* multiples of four and there is still enough data left to be copied,
* try to move it in larger chunks.
*/
if(len >= sizeof(long) && IS_LONG_ALIGNED(to) && IS_LONG_ALIGNED(from))
{
unsigned long * _to = (unsigned long *)to;
unsigned long * _from = (unsigned long *)from;
/* An unrolled transfer loop, which shifts 32 bytes per iteration. */
while(len >= 8 * sizeof(long))
{
/* The following should translate into load/store
opcodes which encode the access offsets (0..7)
into the respective displacement values. This
should help the PowerPC by avoiding pipeline
stalls (removing the postincrement on the address
will do that) but has no noticeable impact on the
68k platform (I checked). */
_to[0] = _from[0];
_to[1] = _from[1];
_to[2] = _from[2];
_to[3] = _from[3];
_to[4] = _from[4];
_to[5] = _from[5];
_to[6] = _from[6];
_to[7] = _from[7];
_to += 8;
_from += 8;
/*
(*_to++) = (*_from++);
(*_to++) = (*_from++);
(*_to++) = (*_from++);
(*_to++) = (*_from++);
(*_to++) = (*_from++);
(*_to++) = (*_from++);
(*_to++) = (*_from++);
(*_to++) = (*_from++);
*/
len -= 8 * sizeof(long);
}
/* Try to mop up any small amounts of data still in need of
* copying...
*/
while(len >= sizeof(long))
{
(*_to++) = (*_from++);
len -= sizeof(long);
}
to = (unsigned char *)_to;
from = (unsigned char *)_from;
}
}
/* If there's anything left, copy the rest. */
while(len-- > 0)
(*to++) = (*from++);
}
void bCopy(const unsigned char * from,unsigned char *to,size_t len)
{
#include "alignment.h"
if(from < to && to < from + len)
{
to += len;
from += len;
/* The setup below is intended to speed up copying larger
* memory blocks. This can be very elaborate and should not be
* done unless a payoff can be expected.
*/
if(len > 4 * sizeof(long))
{
size_t distance;
/* Try to align both source and destination to an even address. */
if(IS_UNALIGNED(to) && IS_UNALIGNED(from))
{
(*--to) = (*--from);
len--;
}
/* Try to align both source and destination to addresses which are
* multiples of four.
*/
if(len >= sizeof(short) && IS_SHORT_ALIGNED(to) && IS_SHORT_ALIGNED(from))
{
(*--to) = (*--from);
(*--to) = (*--from);
len -= sizeof(short);
}
/* Check the distance between source and destination. If it's shorter
* than a long word, don't dive into the copying routine below since
* the overlapping copying may clobber data.
*/
distance = (size_t)(to - from);
/* If both source and destination are aligned to addresses which are
* multiples of four and there is still enough data left to be copied,
* try to move it in larger chunks.
*/
if(distance >= sizeof(long) && len >= sizeof(long) && IS_LONG_ALIGNED(to) && IS_LONG_ALIGNED(from))
{
unsigned long * _to = (unsigned long *)to;
unsigned long * _from = (unsigned long *)from;
/* An unrolled transfer loop, which shifts 32 bytes per iteration. */
while(len >= 8 * sizeof(long))
{
/* The following should translate into load/store
opcodes which encode the access offsets (-1..-8)
into the respective displacement values. This
should help the PowerPC by avoiding pipeline
stalls (removing the predecrement on the address
will do that) but has no noticeable impact on the
68k platform (I checked). */
_to[-1] = _from[-1];
_to[-2] = _from[-2];
_to[-3] = _from[-3];
_to[-4] = _from[-4];
_to[-5] = _from[-5];
_to[-6] = _from[-6];
_to[-7] = _from[-7];
_to[-8] = _from[-8];
_to -= 8;
_from -= 8;
/*
(*--_to) = (*--_from);
(*--_to) = (*--_from);
(*--_to) = (*--_from);
(*--_to) = (*--_from);
(*--_to) = (*--_from);
(*--_to) = (*--_from);
(*--_to) = (*--_from);
(*--_to) = (*--_from);
*/
len -= 8 * sizeof(long);
}
/* Try to mop up any small amounts of data still in need of
* copying...
*/
while(len >= sizeof(long))
{
(*--_to) = (*--_from);
len -= sizeof(long);
}
to = (unsigned char *)_to;
from = (unsigned char *)_from;
}
}
/* If there's anything left, copy the rest. */
while(len-- > 0)
(*--to) = (*--from);
}
else
{
/* The setup below is intended to speed up copying larger
* memory blocks. This can be very elaborate and should not be
* done unless a payoff can be expected.
*/
if(len > 4 * sizeof(long))
{
size_t distance;
/* Try to align both source and destination to an even address. */
if(IS_UNALIGNED(to) && IS_UNALIGNED(from))
{
(*to++) = (*from++);
len--;
}
/* Try to align both source and destination to addresses which are
* multiples of four.
*/
if(len >= sizeof(short) && IS_SHORT_ALIGNED(to) && IS_SHORT_ALIGNED(from))
{
(*to++) = (*from++);
(*to++) = (*from++);
len -= sizeof(short);
}
/* Check the distance between source and destination. If it's shorter
* than a long word, don't dive into the copying routine below since
* the overlapping copying may clobber data.
*/
if(to >= from)
distance = (size_t)(to - from);
else
distance = (size_t)(from - to);
/* If both source and destination are aligned to addresses which are
* multiples of four and there is still enough data left to be copied,
* try to move it in larger chunks.
*/
if(distance >= sizeof(long) && len >= sizeof(long) && IS_LONG_ALIGNED(to) && IS_LONG_ALIGNED(from))
{
unsigned long * _to = (unsigned long *)to;
unsigned long * _from = (unsigned long *)from;
/* An unrolled transfer loop, which shifts 32 bytes per iteration. */
while(len >= 8 * sizeof(long))
{
/* The following should translate into load/store
opcodes which encode the access offsets (0..7)
into the respective displacement values. This
should help the PowerPC by avoiding pipeline
stalls (removing the postincrement on the address
will do that) but has no noticeable impact on the
68k platform (I checked). */
_to[0] = _from[0];
_to[1] = _from[1];
_to[2] = _from[2];
_to[3] = _from[3];
_to[4] = _from[4];
_to[5] = _from[5];
_to[6] = _from[6];
_to[7] = _from[7];
_to += 8;
_from += 8;
/*
(*_to++) = (*_from++);
(*_to++) = (*_from++);
(*_to++) = (*_from++);
(*_to++) = (*_from++);
(*_to++) = (*_from++);
(*_to++) = (*_from++);
(*_to++) = (*_from++);
(*_to++) = (*_from++);
*/
len -= 8 * sizeof(long);
}
/* Try to mop up any small amounts of data still in need of
* copying...
*/
while(len >= sizeof(long))
{
(*_to++) = (*_from++);
len -= sizeof(long);
}
to = (unsigned char *)_to;
from = (unsigned char *)_from;
}
}
/* If there's anything left, copy the rest. */
while(len-- > 0)
(*to++) = (*from++);
}
}
