lkml.org 
[lkml]   [2008]   [Mar]   [20]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    Date
    From
    SubjectRe: [PATCH] kernel: create linux/unaligned.h
    On Thu, 20 Mar 2008 13:16:57 -0700 Harvey Harrison wrote:

    > Add helpers for the following two patterns currently found in the
    > kernel:
    >
    > le32_to_cpu(get_unaligned((__le32 *)p));
    > put_unaligned(cpu_to_le32(x), (__le32 *)p);
    >
    > Becomes:
    > le32_to_cpu_unaligned(p);
    > cpu_to_le32_unaligned(x, p);
    >
    > There are also some hand-rolled functions implementing this
    > with byte-shifts that can be replaced. To avoid new indirect
    > includes of asm/unaligned.h, create linux/unaligned.h to make
    > it opt in for new code that wants to use these helpers.
    >
    > Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
    > ---
    > This is a rollup of all the previous ones, added kerneldocs and
    > have CC'd Randy.
    >
    > include/linux/unaligned.h | 138 +++++++++++++++++++++++++++++++++++++++++++++
    > 1 files changed, 138 insertions(+), 0 deletions(-)
    >
    > diff --git a/include/linux/unaligned.h b/include/linux/unaligned.h
    > new file mode 100644
    > index 0000000..035c1c7
    > --- /dev/null
    > +++ b/include/linux/unaligned.h
    > @@ -0,0 +1,138 @@
    > +#ifndef _LINUX_UNALIGNED_H_
    > +#define _LINUX_UNALIGNED_H_
    > +
    > +#include <linux/types.h>
    > +#include <asm/byteorder.h>
    > +#include <asm/unaligned.h>
    > +
    > +#ifdef __KERNEL__
    > +
    > +/**
    > + * le64_to_cpu_unaligned - read a le64 from a possibly unaligned pointer

    I would write these as "an le64" etc., but then I read them as
    "l e 64".


    > + * @p: pointer to read from
    > + *
    > + * Returns a u64 in cpu byteorder

    And I would write "CPU", but some people don't do that. ;)

    Acked-by: Randy Dunlap <randy.dunlap@oracle.com>


    Thanks.

    > + */
    > +static inline u64 le64_to_cpu_unaligned(void *p)
    > +{
    > + return le64_to_cpu(get_unaligned((__le64 *)p));
    > +}
    > +
    > +/**
    > + * le32_to_cpu_unaligned - read a le32 from a possibly unaligned pointer
    > + * @p: pointer to read from
    > + *
    > + * Returns a u32 in cpu byteorder
    > + */
    > +static inline u32 le32_to_cpu_unaligned(void *p)
    > +{
    > + return le32_to_cpu(get_unaligned((__le32 *)p));
    > +}
    > +
    > +/**
    > + * le16_to_cpu_unaligned - read a le16 from a possibly unaligned pointer
    > + * @p: pointer to read from
    > + *
    > + * Returns a u16 in cpu byteorder
    > + */
    > +static inline u16 le16_to_cpu_unaligned(void *p)
    > +{
    > + return le16_to_cpu(get_unaligned((__le16 *)p));
    > +}
    > +
    > +/**
    > + * be64_to_cpu_unaligned - read a be64 from a possibly unaligned pointer
    > + * @p: pointer to read from
    > + *
    > + * Returns a u64 in cpu byteorder
    > + */
    > +static inline u64 be64_to_cpu_unaligned(void *p)
    > +{
    > + return be64_to_cpu(get_unaligned((__be64 *)p));
    > +}
    > +
    > +/**
    > + * be32_to_cpu_unaligned - read a be32 from a possibly unaligned pointer
    > + * @p: pointer to read from
    > + *
    > + * Returns a u32 in cpu byteorder
    > + */
    > +static inline u32 be32_to_cpu_unaligned(void *p)
    > +{
    > + return be32_to_cpu(get_unaligned((__be32 *)p));
    > +}
    > +
    > +/**
    > + * be16_to_cpu_unaligned - read a be16 from a possibly unaligned pointer
    > + * @p: pointer to read from
    > + *
    > + * Returns a u16 in cpu byteorder
    > + */
    > +static inline u16 be16_to_cpu_unaligned(void *p)
    > +{
    > + return be16_to_cpu(get_unaligned((__be16 *)p));
    > +}
    > +
    > +/**
    > + * le64_to_cpu_unaligned - write a u64 in le-byteorder to a possibly unaligned pointer
    > + * @val: value to be written
    > + * @p: pointer to write to
    > + */
    > +static inline void cpu_to_le64_unaligned(u64 val, void *p)
    > +{
    > + put_unaligned(cpu_to_le64(val), (__le64 *)p);
    > +}
    > +
    > +/**
    > + * le32_to_cpu_unaligned - write a u32 in le-byteorder to a possibly unaligned pointer
    > + * @val: value to be written
    > + * @p: pointer to write to
    > + */
    > +static inline void cpu_to_le32_unaligned(u32 val, void *p)
    > +{
    > + put_unaligned(cpu_to_le32(val), (__le32 *)p);
    > +}
    > +
    > +/**
    > + * le16_to_cpu_unaligned - write a u16 in le-byteorder to a possibly unaligned pointer
    > + * @val: value to be written
    > + * @p: pointer to write to
    > + */
    > +static inline void cpu_to_le16_unaligned(u16 val, void *p)
    > +{
    > + put_unaligned(cpu_to_le16(val), (__le16 *)p);
    > +}
    > +
    > +/**
    > + * be64_to_cpu_unaligned - write a u64 in be-byteorder to a possibly unaligned pointer
    > + * @val: value to be written
    > + * @p: pointer to write to
    > + */
    > +static inline void cpu_to_be64_unaligned(u64 val, void *p)
    > +{
    > + put_unaligned(cpu_to_be64(val), (__be64 *)p);
    > +}
    > +
    > +/**
    > + * be32_to_cpu_unaligned - write a u32 in be-byteorder to a possibly unaligned pointer
    > + * @val: value to be written
    > + * @p: pointer to write to
    > + */
    > +static inline void cpu_to_be32_unaligned(u32 val, void *p)
    > +{
    > + put_unaligned(cpu_to_be32(val), (__be32 *)p);
    > +}
    > +
    > +/**
    > + * be16_to_cpu_unaligned - write a u16 in be-byteorder to a possibly unaligned pointer
    > + * @val: value to be written
    > + * @p: pointer to write to
    > + */
    > +static inline void cpu_to_be16_unaligned(u16 val, void *p)
    > +{
    > + put_unaligned(cpu_to_be16(val), (__be16 *)p);
    > +}
    > +
    > +#endif /* KERNEL */
    > +
    > +#endif /* _LINUX_UNALIGNED_H */
    > --

    ---
    ~Randy


    \
     
     \ /
      Last update: 2008-03-20 21:43    [W:0.034 / U:76.132 seconds]
    ©2003-2017 Jasper Spaans. hosted at Digital OceanAdvertise on this site