lkml.org 
[lkml]   [2007]   [Dec]   [20]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    Subject[PATCH v4 7/8] debugfs: allow access to signed values
    debugfs: allow access to signed values

    Add debugfs_create_s{8,16,32,64}. For these to work properly, we need to remove
    a cast in libfs, change the simple_attr_open prototype and thus fix the users as
    well.

    Cc: Johannes Berg <johannes@sipsolutions.net>
    Cc: Mattias Nissler <mattias.nissler@gmx.de>
    To: Greg Kroah-Hartman <gregkh@suse.de>
    To: Arnd Bergmann <arndb@de.ibm.com>
    To: Akinobu Mita <akinobu.mita@gmail.com>
    Signed-off-by: Stefano Brivio <stefano.brivio@polimi.it>
    ---

    This version addresses last Johannes' concerns.

    ---
    arch/powerpc/platforms/cell/spufs/file.c | 48 ++++----
    fs/debugfs/file.c | 186 +++++++++++++++++++++++++++++--
    fs/libfs.c | 23 ++-
    include/linux/debugfs.h | 38 ++++++
    include/linux/fs.h | 25 ++--
    lib/fault-inject.c | 11 +
    6 files changed, 268 insertions(+), 63 deletions(-)

    Index: wireless-2.6/fs/debugfs/file.c
    ===================================================================
    --- wireless-2.6.orig/fs/debugfs/file.c
    +++ wireless-2.6/fs/debugfs/file.c
    @@ -56,11 +56,11 @@ const struct inode_operations debugfs_li
    .follow_link = debugfs_follow_link,
    };

    -static void debugfs_u8_set(void *data, u64 val)
    +static void debugfs_u8_set(void *data, unsigned long long val)
    {
    *(u8 *)data = val;
    }
    -static u64 debugfs_u8_get(void *data)
    +static unsigned long long debugfs_u8_get(void *data)
    {
    return *(u8 *)data;
    }
    @@ -97,11 +97,11 @@ struct dentry *debugfs_create_u8(const c
    }
    EXPORT_SYMBOL_GPL(debugfs_create_u8);

    -static void debugfs_u16_set(void *data, u64 val)
    +static void debugfs_u16_set(void *data, unsigned long long val)
    {
    *(u16 *)data = val;
    }
    -static u64 debugfs_u16_get(void *data)
    +static unsigned long long debugfs_u16_get(void *data)
    {
    return *(u16 *)data;
    }
    @@ -138,11 +138,11 @@ struct dentry *debugfs_create_u16(const
    }
    EXPORT_SYMBOL_GPL(debugfs_create_u16);

    -static void debugfs_u32_set(void *data, u64 val)
    +static void debugfs_u32_set(void *data, unsigned long long val)
    {
    *(u32 *)data = val;
    }
    -static u64 debugfs_u32_get(void *data)
    +static unsigned long long debugfs_u32_get(void *data)
    {
    return *(u32 *)data;
    }
    @@ -179,12 +179,12 @@ struct dentry *debugfs_create_u32(const
    }
    EXPORT_SYMBOL_GPL(debugfs_create_u32);

    -static void debugfs_u64_set(void *data, u64 val)
    +static void debugfs_u64_set(void *data, unsigned long long val)
    {
    *(u64 *)data = val;
    }

    -static u64 debugfs_u64_get(void *data)
    +static unsigned long long debugfs_u64_get(void *data)
    {
    return *(u64 *)data;
    }
    @@ -221,6 +221,172 @@ struct dentry *debugfs_create_u64(const
    }
    EXPORT_SYMBOL_GPL(debugfs_create_u64);

    +
    +static void debugfs_s8_set(void *data, unsigned long long val)
    +{
    + *(s8 *)data = val;
    +}
    +static unsigned long long debugfs_s8_get(void *data)
    +{
    + return *(s8 *)data;
    +}
    +DEFINE_SIMPLE_ATTRIBUTE(fops_s8, debugfs_s8_get, debugfs_s8_set, "%lld\n");
    +
    +/**
    + * debugfs_create_s8 - create a debugfs file that is used to read and write a signed 8-bit value
    + * @name: a pointer to a string containing the name of the file to create.
    + * @mode: the permission that the file should have
    + * @parent: a pointer to the parent dentry for this file. This should be a
    + * directory dentry if set. If this parameter is %NULL, then the
    + * file will be created in the root of the debugfs filesystem.
    + * @value: a pointer to the variable that the file should read to and write
    + * from.
    + *
    + * This function creates a file in debugfs with the given name that
    + * contains the value of the variable @value. If the @mode variable is so
    + * set, it can be read from, and written to.
    + *
    + * This function will return a pointer to a dentry if it succeeds. This
    + * pointer must be passed to the debugfs_remove() function when the file is
    + * to be removed (no automatic cleanup happens if your module is unloaded,
    + * you are responsible here.) If an error occurs, %NULL will be returned.
    + *
    + * If debugfs is not enabled in the kernel, the value -%ENODEV will be
    + * returned. It is not wise to check for this value, but rather, check for
    + * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
    + * code.
    + */
    +struct dentry *debugfs_create_s8(const char *name, mode_t mode,
    + struct dentry *parent, s8 *value)
    +{
    + return debugfs_create_file(name, mode, parent, value, &fops_s8);
    +}
    +EXPORT_SYMBOL_GPL(debugfs_create_s8);
    +
    +static void debugfs_s16_set(void *data, unsigned long long val)
    +{
    + *(s16 *)data = val;
    +}
    +static unsigned long long debugfs_s16_get(void *data)
    +{
    + return *(s16 *)data;
    +}
    +DEFINE_SIMPLE_ATTRIBUTE(fops_s16, debugfs_s16_get, debugfs_s16_set, "%lld\n");
    +
    +/**
    + * debugfs_create_s16 - create a debugfs file that is used to read and write a signed 16-bit value
    + * @name: a pointer to a string containing the name of the file to create.
    + * @mode: the permission that the file should have
    + * @parent: a pointer to the parent dentry for this file. This should be a
    + * directory dentry if set. If this parameter is %NULL, then the
    + * file will be created in the root of the debugfs filesystem.
    + * @value: a pointer to the variable that the file should read to and write
    + * from.
    + *
    + * This function creates a file in debugfs with the given name that
    + * contains the value of the variable @value. If the @mode variable is so
    + * set, it can be read from, and written to.
    + *
    + * This function will return a pointer to a dentry if it succeeds. This
    + * pointer must be passed to the debugfs_remove() function when the file is
    + * to be removed (no automatic cleanup happens if your module is unloaded,
    + * you are responsible here.) If an error occurs, %NULL will be returned.
    + *
    + * If debugfs is not enabled in the kernel, the value -%ENODEV will be
    + * returned. It is not wise to check for this value, but rather, check for
    + * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
    + * code.
    + */
    +struct dentry *debugfs_create_s16(const char *name, mode_t mode,
    + struct dentry *parent, s16 *value)
    +{
    + return debugfs_create_file(name, mode, parent, value, &fops_s16);
    +}
    +EXPORT_SYMBOL_GPL(debugfs_create_s16);
    +
    +static void debugfs_s32_set(void *data, unsigned long long val)
    +{
    + *(s32 *)data = val;
    +}
    +static unsigned long long debugfs_s32_get(void *data)
    +{
    + return *(s32 *)data;
    +}
    +DEFINE_SIMPLE_ATTRIBUTE(fops_s32, debugfs_s32_get, debugfs_s32_set, "%lld\n");
    +
    +/**
    + * debugfs_create_s32 - create a debugfs file that is used to read and write a signed 32-bit value
    + * @name: a pointer to a string containing the name of the file to create.
    + * @mode: the permission that the file should have
    + * @parent: a pointer to the parent dentry for this file. This should be a
    + * directory dentry if set. If this parameter is %NULL, then the
    + * file will be created in the root of the debugfs filesystem.
    + * @value: a pointer to the variable that the file should read to and write
    + * from.
    + *
    + * This function creates a file in debugfs with the given name that
    + * contains the value of the variable @value. If the @mode variable is so
    + * set, it can be read from, and written to.
    + *
    + * This function will return a pointer to a dentry if it succeeds. This
    + * pointer must be passed to the debugfs_remove() function when the file is
    + * to be removed (no automatic cleanup happens if your module is unloaded,
    + * you are responsible here.) If an error occurs, %NULL will be returned.
    + *
    + * If debugfs is not enabled in the kernel, the value -%ENODEV will be
    + * returned. It is not wise to check for this value, but rather, check for
    + * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
    + * code.
    + */
    +struct dentry *debugfs_create_s32(const char *name, mode_t mode,
    + struct dentry *parent, s32 *value)
    +{
    + return debugfs_create_file(name, mode, parent, value, &fops_s32);
    +}
    +EXPORT_SYMBOL_GPL(debugfs_create_s32);
    +
    +static void debugfs_s64_set(void *data, unsigned long long val)
    +{
    + *(s64 *)data = val;
    +}
    +
    +static unsigned long long debugfs_s64_get(void *data)
    +{
    + return *(s64 *)data;
    +}
    +DEFINE_SIMPLE_ATTRIBUTE(fops_s64, debugfs_s64_get, debugfs_s64_set, "%lld\n");
    +
    +/**
    + * debugfs_create_s64 - create a debugfs file that is used to read and write a signed 64-bit value
    + * @name: a pointer to a string containing the name of the file to create.
    + * @mode: the permission that the file should have
    + * @parent: a pointer to the parent dentry for this file. This should be a
    + * directory dentry if set. If this parameter is %NULL, then the
    + * file will be created in the root of the debugfs filesystem.
    + * @value: a pointer to the variable that the file should read to and write
    + * from.
    + *
    + * This function creates a file in debugfs with the given name that
    + * contains the value of the variable @value. If the @mode variable is so
    + * set, it can be read from, and written to.
    + *
    + * This function will return a pointer to a dentry if it succeeds. This
    + * pointer must be passed to the debugfs_remove() function when the file is
    + * to be removed (no automatic cleanup happens if your module is unloaded,
    + * you are responsible here.) If an error occurs, %NULL will be returned.
    + *
    + * If debugfs is not enabled in the kernel, the value -%ENODEV will be
    + * returned. It is not wise to check for this value, but rather, check for
    + * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
    + * code.
    + */
    +struct dentry *debugfs_create_s64(const char *name, mode_t mode,
    + struct dentry *parent, s64 *value)
    +{
    + return debugfs_create_file(name, mode, parent, value, &fops_s64);
    +}
    +EXPORT_SYMBOL_GPL(debugfs_create_s64);
    +
    DEFINE_SIMPLE_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n");

    DEFINE_SIMPLE_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set, "0x%04llx\n");
    @@ -291,7 +457,7 @@ static ssize_t read_file_bool(struct fil
    {
    char buf[3];
    u32 *val = file->private_data;
    -
    +
    if (*val)
    buf[0] = 'Y';
    else
    @@ -324,7 +490,7 @@ static ssize_t write_file_bool(struct fi
    *val = 0;
    break;
    }
    -
    +
    return count;
    }

    Index: wireless-2.6/fs/libfs.c
    ===================================================================
    --- wireless-2.6.orig/fs/libfs.c
    +++ wireless-2.6/fs/libfs.c
    @@ -59,7 +59,7 @@ int simple_sync_file(struct file * file,
    {
    return 0;
    }
    -
    +
    int dcache_dir_open(struct inode *inode, struct file *file)
    {
    static struct qstr cursor_name = {.len = 1, .name = "."};
    @@ -160,9 +160,9 @@ int dcache_readdir(struct file * filp, v
    continue;

    spin_unlock(&dcache_lock);
    - if (filldir(dirent, next->d_name.name,
    - next->d_name.len, filp->f_pos,
    - next->d_inode->i_ino,
    + if (filldir(dirent, next->d_name.name,
    + next->d_name.len, filp->f_pos,
    + next->d_inode->i_ino,
    dt_type(next->d_inode)) < 0)
    return 0;
    spin_lock(&dcache_lock);
    @@ -586,10 +586,10 @@ int simple_transaction_release(struct in
    /* Simple attribute files */

    struct simple_attr {
    - u64 (*get)(void *);
    - void (*set)(void *, u64);
    - char get_buf[24]; /* enough to store a u64 and "\n\0" */
    - char set_buf[24];
    + unsigned long long (*get)(void *);
    + void (*set)(void *, unsigned long long);
    + char get_buf[sizeof(unsigned long long) + 2]; /* ULL + "\n\0" */
    + char set_buf[sizeof(unsigned long long) + 2];
    void *data;
    const char *fmt; /* format for read operation */
    struct mutex mutex; /* protects access to these buffers */
    @@ -598,7 +598,8 @@ struct simple_attr {
    /* simple_attr_open is called by an actual attribute open file operation
    * to set the attribute specific access operations. */
    int simple_attr_open(struct inode *inode, struct file *file,
    - u64 (*get)(void *), void (*set)(void *, u64),
    + unsigned long long (*get)(void *),
    + void (*set)(void *, unsigned long long),
    const char *fmt)
    {
    struct simple_attr *attr;
    @@ -643,7 +644,7 @@ ssize_t simple_attr_read(struct file *fi
    else /* first read */
    size = scnprintf(attr->get_buf, sizeof(attr->get_buf),
    attr->fmt,
    - (unsigned long long)attr->get(attr->data));
    + attr->get(attr->data));

    ret = simple_read_from_buffer(buf, len, ppos, attr->get_buf, size);
    mutex_unlock(&attr->mutex);
    @@ -655,7 +656,7 @@ ssize_t simple_attr_write(struct file *f
    size_t len, loff_t *ppos)
    {
    struct simple_attr *attr;
    - u64 val;
    + unsigned long long val;
    size_t size;
    ssize_t ret;

    Index: wireless-2.6/include/linux/debugfs.h
    ===================================================================
    --- wireless-2.6.orig/include/linux/debugfs.h
    +++ wireless-2.6/include/linux/debugfs.h
    @@ -49,6 +49,14 @@ struct dentry *debugfs_create_u32(const
    struct dentry *parent, u32 *value);
    struct dentry *debugfs_create_u64(const char *name, mode_t mode,
    struct dentry *parent, u64 *value);
    +struct dentry *debugfs_create_s8(const char *name, mode_t mode,
    + struct dentry *parent, s8 *value);
    +struct dentry *debugfs_create_s16(const char *name, mode_t mode,
    + struct dentry *parent, s16 *value);
    +struct dentry *debugfs_create_s32(const char *name, mode_t mode,
    + struct dentry *parent, s32 *value);
    +struct dentry *debugfs_create_s64(const char *name, mode_t mode,
    + struct dentry *parent, s64 *value);
    struct dentry *debugfs_create_x8(const char *name, mode_t mode,
    struct dentry *parent, u8 *value);
    struct dentry *debugfs_create_x16(const char *name, mode_t mode,
    @@ -65,7 +73,7 @@ struct dentry *debugfs_create_blob(const

    #include <linux/err.h>

    -/*
    +/*
    * We do not return NULL from these functions if CONFIG_DEBUG_FS is not enabled
    * so users have a chance to detect if there was a real error or not. We don't
    * want to duplicate the design decision mistakes of procfs and devfs again.
    @@ -128,6 +136,34 @@ static inline struct dentry *debugfs_cre
    return ERR_PTR(-ENODEV);
    }

    +static inline struct dentry *debugfs_create_s8(const char *name, mode_t mode,
    + struct dentry *parent,
    + u8 *value)
    +{
    + return ERR_PTR(-ENODEV);
    +}
    +
    +static inline struct dentry *debugfs_create_s16(const char *name, mode_t mode,
    + struct dentry *parent,
    + s16 *value)
    +{
    + return ERR_PTR(-ENODEV);
    +}
    +
    +static inline struct dentry *debugfs_create_s32(const char *name, mode_t mode,
    + struct dentry *parent,
    + s32 *value)
    +{
    + return ERR_PTR(-ENODEV);
    +}
    +
    +static inline struct dentry *debugfs_create_s64(const char *name, mode_t mode,
    + struct dentry *parent,
    + s64 *value)
    +{
    + return ERR_PTR(-ENODEV);
    +}
    +
    static inline struct dentry *debugfs_create_x8(const char *name, mode_t mode,
    struct dentry *parent,
    u8 *value)
    Index: wireless-2.6/arch/powerpc/platforms/cell/spufs/file.c
    ===================================================================
    --- wireless-2.6.orig/arch/powerpc/platforms/cell/spufs/file.c
    +++ wireless-2.6/arch/powerpc/platforms/cell/spufs/file.c
    @@ -286,10 +286,10 @@ static int spufs_cntl_mmap(struct file *
    #define spufs_cntl_mmap NULL
    #endif /* !SPUFS_MMAP_4K */

    -static u64 spufs_cntl_get(void *data)
    +static unsigned long long spufs_cntl_get(void *data)
    {
    struct spu_context *ctx = data;
    - u64 val;
    + unsigned long long val;

    spu_acquire(ctx);
    val = ctx->ops->status_read(ctx);
    @@ -298,7 +298,7 @@ static u64 spufs_cntl_get(void *data)
    return val;
    }

    -static void spufs_cntl_set(void *data, u64 val)
    +static void spufs_cntl_set(void *data, unsigned long long val)
    {
    struct spu_context *ctx = data;

    @@ -1086,10 +1086,10 @@ static const struct file_operations spuf
    #define SPU_ATTR_ACQUIRE_SAVED 2

    #define DEFINE_SPUFS_ATTRIBUTE(__name, __get, __set, __fmt, __acquire) \
    -static u64 __##__get(void *data) \
    +static unsigned long long __##__get(void *data) \
    { \
    struct spu_context *ctx = data; \
    - u64 ret; \
    + unsigned long long ret; \
    \
    if (__acquire == SPU_ATTR_ACQUIRE) { \
    spu_acquire(ctx); \
    @@ -1106,7 +1106,7 @@ static u64 __##__get(void *data) \
    } \
    DEFINE_SIMPLE_ATTRIBUTE(__name, __##__get, __set, __fmt);

    -static void spufs_signal1_type_set(void *data, u64 val)
    +static void spufs_signal1_type_set(void *data, unsigned long long val)
    {
    struct spu_context *ctx = data;

    @@ -1115,7 +1115,7 @@ static void spufs_signal1_type_set(void
    spu_release(ctx);
    }

    -static u64 spufs_signal1_type_get(struct spu_context *ctx)
    +static unsigned long long spufs_signal1_type_get(struct spu_context *ctx)
    {
    return ctx->ops->signal1_type_get(ctx);
    }
    @@ -1123,7 +1123,7 @@ DEFINE_SPUFS_ATTRIBUTE(spufs_signal1_typ
    spufs_signal1_type_set, "%llu", SPU_ATTR_ACQUIRE);


    -static void spufs_signal2_type_set(void *data, u64 val)
    +static void spufs_signal2_type_set(void *data, unsigned long long val)
    {
    struct spu_context *ctx = data;

    @@ -1132,7 +1132,7 @@ static void spufs_signal2_type_set(void
    spu_release(ctx);
    }

    -static u64 spufs_signal2_type_get(struct spu_context *ctx)
    +static unsigned long long spufs_signal2_type_get(struct spu_context *ctx)
    {
    return ctx->ops->signal2_type_get(ctx);
    }
    @@ -1605,7 +1605,7 @@ static const struct file_operations spuf
    .mmap = spufs_mfc_mmap,
    };

    -static void spufs_npc_set(void *data, u64 val)
    +static void spufs_npc_set(void *data, unsigned long long val)
    {
    struct spu_context *ctx = data;
    spu_acquire(ctx);
    @@ -1613,14 +1613,14 @@ static void spufs_npc_set(void *data, u6
    spu_release(ctx);
    }

    -static u64 spufs_npc_get(struct spu_context *ctx)
    +static unsigned long long spufs_npc_get(struct spu_context *ctx)
    {
    return ctx->ops->npc_read(ctx);
    }
    DEFINE_SPUFS_ATTRIBUTE(spufs_npc_ops, spufs_npc_get, spufs_npc_set,
    "0x%llx\n", SPU_ATTR_ACQUIRE);

    -static void spufs_decr_set(void *data, u64 val)
    +static void spufs_decr_set(void *data, unsigned long long val)
    {
    struct spu_context *ctx = data;
    struct spu_lscsa *lscsa = ctx->csa.lscsa;
    @@ -1629,7 +1629,7 @@ static void spufs_decr_set(void *data, u
    spu_release_saved(ctx);
    }

    -static u64 spufs_decr_get(struct spu_context *ctx)
    +static unsigned long long spufs_decr_get(struct spu_context *ctx)
    {
    struct spu_lscsa *lscsa = ctx->csa.lscsa;
    return lscsa->decr.slot[0];
    @@ -1637,7 +1637,7 @@ static u64 spufs_decr_get(struct spu_con
    DEFINE_SPUFS_ATTRIBUTE(spufs_decr_ops, spufs_decr_get, spufs_decr_set,
    "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED);

    -static void spufs_decr_status_set(void *data, u64 val)
    +static void spufs_decr_status_set(void *data, unsigned long long val)
    {
    struct spu_context *ctx = data;
    spu_acquire_saved(ctx);
    @@ -1648,7 +1648,7 @@ static void spufs_decr_status_set(void *
    spu_release_saved(ctx);
    }

    -static u64 spufs_decr_status_get(struct spu_context *ctx)
    +static unsigned long long spufs_decr_status_get(struct spu_context *ctx)
    {
    if (ctx->csa.priv2.mfc_control_RW & MFC_CNTL_DECREMENTER_RUNNING)
    return SPU_DECR_STATUS_RUNNING;
    @@ -1659,7 +1659,7 @@ DEFINE_SPUFS_ATTRIBUTE(spufs_decr_status
    spufs_decr_status_set, "0x%llx\n",
    SPU_ATTR_ACQUIRE_SAVED);

    -static void spufs_event_mask_set(void *data, u64 val)
    +static void spufs_event_mask_set(void *data, unsigned long long val)
    {
    struct spu_context *ctx = data;
    struct spu_lscsa *lscsa = ctx->csa.lscsa;
    @@ -1668,7 +1668,7 @@ static void spufs_event_mask_set(void *d
    spu_release_saved(ctx);
    }

    -static u64 spufs_event_mask_get(struct spu_context *ctx)
    +static unsigned long long spufs_event_mask_get(struct spu_context *ctx)
    {
    struct spu_lscsa *lscsa = ctx->csa.lscsa;
    return lscsa->event_mask.slot[0];
    @@ -1678,7 +1678,7 @@ DEFINE_SPUFS_ATTRIBUTE(spufs_event_mask_
    spufs_event_mask_set, "0x%llx\n",
    SPU_ATTR_ACQUIRE_SAVED);

    -static u64 spufs_event_status_get(struct spu_context *ctx)
    +static unsigned long long spufs_event_status_get(struct spu_context *ctx)
    {
    struct spu_state *state = &ctx->csa;
    u64 stat;
    @@ -1690,7 +1690,7 @@ static u64 spufs_event_status_get(struct
    DEFINE_SPUFS_ATTRIBUTE(spufs_event_status_ops, spufs_event_status_get,
    NULL, "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED)

    -static void spufs_srr0_set(void *data, u64 val)
    +static void spufs_srr0_set(void *data, unsigned long long val)
    {
    struct spu_context *ctx = data;
    struct spu_lscsa *lscsa = ctx->csa.lscsa;
    @@ -1699,7 +1699,7 @@ static void spufs_srr0_set(void *data, u
    spu_release_saved(ctx);
    }

    -static u64 spufs_srr0_get(struct spu_context *ctx)
    +static unsigned long long spufs_srr0_get(struct spu_context *ctx)
    {
    struct spu_lscsa *lscsa = ctx->csa.lscsa;
    return lscsa->srr0.slot[0];
    @@ -1707,7 +1707,7 @@ static u64 spufs_srr0_get(struct spu_con
    DEFINE_SPUFS_ATTRIBUTE(spufs_srr0_ops, spufs_srr0_get, spufs_srr0_set,
    "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED)

    -static u64 spufs_id_get(struct spu_context *ctx)
    +static unsigned long long spufs_id_get(struct spu_context *ctx)
    {
    u64 num;

    @@ -1721,13 +1721,13 @@ static u64 spufs_id_get(struct spu_conte
    DEFINE_SPUFS_ATTRIBUTE(spufs_id_ops, spufs_id_get, NULL, "0x%llx\n",
    SPU_ATTR_ACQUIRE)

    -static u64 spufs_object_id_get(struct spu_context *ctx)
    +static unsigned long long spufs_object_id_get(struct spu_context *ctx)
    {
    /* FIXME: Should there really be no locking here? */
    return ctx->object_id;
    }

    -static void spufs_object_id_set(void *data, u64 id)
    +static void spufs_object_id_set(void *data, unsigned long long id)
    {
    struct spu_context *ctx = data;
    ctx->object_id = id;
    @@ -1736,7 +1736,7 @@ static void spufs_object_id_set(void *da
    DEFINE_SPUFS_ATTRIBUTE(spufs_object_id_ops, spufs_object_id_get,
    spufs_object_id_set, "0x%llx\n", SPU_ATTR_NOACQUIRE);

    -static u64 spufs_lslr_get(struct spu_context *ctx)
    +static unsigned long long spufs_lslr_get(struct spu_context *ctx)
    {
    return ctx->csa.priv2.spu_lslr_RW;
    }
    Index: wireless-2.6/include/linux/fs.h
    ===================================================================
    --- wireless-2.6.orig/include/linux/fs.h
    +++ wireless-2.6/include/linux/fs.h
    @@ -15,8 +15,8 @@
    * nr_file rlimit, so it's safe to set up a ridiculously high absolute
    * upper limit on files-per-process.
    *
    - * Some programs (notably those using select()) may have to be
    - * recompiled to take full advantage of the new limits..
    + * Some programs (notably those using select()) may have to be
    + * recompiled to take full advantage of the new limits..
    */

    /* Fixed constants first: */
    @@ -90,7 +90,7 @@ extern int dir_notify_enable;
    #define SEL_EX 4

    /* public flags for file_system_type */
    -#define FS_REQUIRES_DEV 1
    +#define FS_REQUIRES_DEV 1
    #define FS_BINARY_MOUNTDATA 2
    #define FS_HAS_SUBTYPE 4
    #define FS_REVAL_DOT 16384 /* Check the paths ".", ".." for staleness */
    @@ -365,7 +365,7 @@ struct iattr {
    */
    #include <linux/quota.h>

    -/**
    +/**
    * enum positive_aop_returns - aop return codes with specific semantics
    *
    * @AOP_WRITEPAGE_ACTIVATE: Informs the caller that page writeback has
    @@ -375,7 +375,7 @@ struct iattr {
    * be a candidate for writeback again in the near
    * future. Other callers must be careful to unlock
    * the page if they get this return. Returned by
    - * writepage();
    + * writepage();
    *
    * @AOP_TRUNCATED_PAGE: The AOP method that was handed a locked page has
    * unlocked it and the page might have been truncated.
    @@ -818,10 +818,10 @@ extern spinlock_t files_lock;

    #define MAX_NON_LFS ((1UL<<31) - 1)

    -/* Page cache limit. The filesystems should put that into their s_maxbytes
    - limits, otherwise bad things can happen in VM. */
    +/* Page cache limit. The filesystems should put that into their s_maxbytes
    + limits, otherwise bad things can happen in VM. */
    #if BITS_PER_LONG==32
    -#define MAX_LFS_FILESIZE (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
    +#define MAX_LFS_FILESIZE (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
    #elif BITS_PER_LONG==64
    #define MAX_LFS_FILESIZE 0x7fffffffffffffffUL
    #endif
    @@ -1240,7 +1240,7 @@ struct super_operations {
    void (*destroy_inode)(struct inode *);

    void (*read_inode) (struct inode *);
    -
    +
    void (*dirty_inode) (struct inode *);
    int (*write_inode) (struct inode *, int);
    void (*put_inode) (struct inode *);
    @@ -1719,7 +1719,7 @@ extern int may_open(struct nameidata *,

    extern int kernel_read(struct file *, unsigned long, char *, unsigned long);
    extern struct file * open_exec(const char *);
    -
    +
    /* fs/dcache.c -- generic fs support functions */
    extern int is_subdir(struct dentry *, struct dentry *);
    extern ino_t find_inode_number(struct dentry *, struct qstr *);
    @@ -1753,7 +1753,7 @@ extern void unlock_new_inode(struct inod
    static inline struct inode *iget(struct super_block *sb, unsigned long ino)
    {
    struct inode *inode = iget_locked(sb, ino);
    -
    +
    if (inode && (inode->i_state & I_NEW)) {
    sb->s_op->read_inode(inode);
    unlock_new_inode(inode);
    @@ -2062,7 +2062,8 @@ __simple_attr_check_format(const char *f
    }

    int simple_attr_open(struct inode *inode, struct file *file,
    - u64 (*get)(void *), void (*set)(void *, u64),
    + unsigned long long (*get)(void *),
    + void (*set)(void *, unsigned long long),
    const char *fmt);
    int simple_attr_close(struct inode *inode, struct file *file);
    ssize_t simple_attr_read(struct file *file, char __user *buf,
    Index: wireless-2.6/lib/fault-inject.c
    ===================================================================
    --- wireless-2.6.orig/lib/fault-inject.c
    +++ wireless-2.6/lib/fault-inject.c
    @@ -134,13 +134,14 @@ bool should_fail(struct fault_attr *attr

    #ifdef CONFIG_FAULT_INJECTION_DEBUG_FS

    -static void debugfs_ul_set(void *data, u64 val)
    +static void debugfs_ul_set(void *data, unsigned long long val)
    {
    *(unsigned long *)data = val;
    }

    #ifdef CONFIG_FAULT_INJECTION_STACKTRACE_FILTER
    -static void debugfs_ul_set_MAX_STACK_TRACE_DEPTH(void *data, u64 val)
    +static void debugfs_ul_set_MAX_STACK_TRACE_DEPTH(void *data,
    + unsigned long long val)
    {
    *(unsigned long *)data =
    val < MAX_STACK_TRACE_DEPTH ?
    @@ -148,7 +149,7 @@ static void debugfs_ul_set_MAX_STACK_TRA
    }
    #endif /* CONFIG_FAULT_INJECTION_STACKTRACE_FILTER */

    -static u64 debugfs_ul_get(void *data)
    +static unsigned long long debugfs_ul_get(void *data)
    {
    return *(unsigned long *)data;
    }
    @@ -174,12 +175,12 @@ static struct dentry *debugfs_create_ul_
    }
    #endif /* CONFIG_FAULT_INJECTION_STACKTRACE_FILTER */

    -static void debugfs_atomic_t_set(void *data, u64 val)
    +static void debugfs_atomic_t_set(void *data, unsigned long long val)
    {
    atomic_set((atomic_t *)data, val);
    }

    -static u64 debugfs_atomic_t_get(void *data)
    +static unsigned long long debugfs_atomic_t_get(void *data)
    {
    return atomic_read((atomic_t *)data);
    }


    --
    Ciao
    Stefano


    \
     
     \ /
      Last update: 2007-12-20 13:25    [W:0.070 / U:0.496 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site