int (*inode_getxattr) (struct dentry *dentry, char *name);
        int (*inode_listxattr) (struct dentry *dentry);
        int (*inode_removexattr) (struct dentry *dentry, char *name);
-       char *(*inode_xattr_getsuffix) (void);
-       int (*inode_getsecurity)(struct inode *inode, const char *name, void *buffer, size_t size, int err);
+       const char *(*inode_xattr_getsuffix) (void);
+       int (*inode_getsecurity)(const struct inode *inode, const char *name, void *buffer, size_t size, int err);
        int (*inode_setsecurity)(struct inode *inode, const char *name, const void *value, size_t size, int flags);
        int (*inode_listsecurity)(struct inode *inode, char *buffer, size_t buffer_size);
 
        return security_ops->inode_xattr_getsuffix();
 }
 
-static inline int security_inode_getsecurity(struct inode *inode, const char *name, void *buffer, size_t size, int err)
+static inline int security_inode_getsecurity(const struct inode *inode, const char *name, void *buffer, size_t size, int err)
 {
        if (unlikely (IS_PRIVATE (inode)))
                return 0;
        return NULL ;
 }
 
-static inline int security_inode_getsecurity(struct inode *inode, const char *name, void *buffer, size_t size, int err)
+static inline int security_inode_getsecurity(const struct inode *inode, const char *name, void *buffer, size_t size, int err)
 {
        return -EOPNOTSUPP;
 }
 
        }
 
        ctx = kmalloc(len, gfp_mask);
-       if (!ctx) {
+       if (!ctx)
                goto error_path;
-               return;
-       }
 
        len = security_getprocattr(current, "current", ctx, len);
        if (len < 0 )
                goto error_path;
 
        audit_log_format(ab, " subj=%s", ctx);
+       return;
 
 error_path:
        if (ctx)
                kfree(ctx);
-       audit_panic("security_getprocattr error in audit_log_task_context");
+       audit_panic("error in audit_log_task_context");
        return;
 }
 
 void audit_inode_context(int idx, const struct inode *inode)
 {
        struct audit_context *context = current->audit_context;
+       const char *suffix = security_inode_xattr_getsuffix();
        char *ctx = NULL;
        int len = 0;
 
-       if (!security_inode_xattr_getsuffix())
-               return;
+       if (!suffix)
+               goto ret;
 
-       len = security_inode_getsecurity(inode, (char *)security_inode_xattr_getsuffix(), NULL, 0, 0);
+       len = security_inode_getsecurity(inode, suffix, NULL, 0, 0);
+       if (len == -EOPNOTSUPP)
+               goto ret;
        if (len < 0) 
                goto error_path;
 
        if (!ctx) 
                goto error_path;
 
-       len = security_inode_getsecurity(inode, (char *)security_inode_xattr_getsuffix(), ctx, len, 0);
+       len = security_inode_getsecurity(inode, suffix, ctx, len, 0);
        if (len < 0)
                goto error_path;
 
        kfree(context->names[idx].ctx);
        context->names[idx].ctx = ctx;
-       return;
+       goto ret;
 
 error_path:
        if (ctx)
                kfree(ctx);
        audit_panic("error in audit_inode_context");
+ret:
        return;
 }
 
 
        return 0;
 }
 
-static int dummy_inode_getsecurity(struct inode *inode, const char *name, void *buffer, size_t size, int err)
+static int dummy_inode_getsecurity(const struct inode *inode, const char *name, void *buffer, size_t size, int err)
 {
        return -EOPNOTSUPP;
 }
        return 0;
 }
 
+static const char *dummy_inode_xattr_getsuffix(void)
+{
+       return NULL;
+}
+
 static int dummy_file_permission (struct file *file, int mask)
 {
        return 0;
        set_to_dummy_if_null(ops, inode_getxattr);
        set_to_dummy_if_null(ops, inode_listxattr);
        set_to_dummy_if_null(ops, inode_removexattr);
+       set_to_dummy_if_null(ops, inode_xattr_getsuffix);
        set_to_dummy_if_null(ops, inode_getsecurity);
        set_to_dummy_if_null(ops, inode_setsecurity);
        set_to_dummy_if_null(ops, inode_listsecurity);
 
  *
  * Permission check is handled by selinux_inode_getxattr hook.
  */
-static int selinux_inode_getsecurity(struct inode *inode, const char *name, void *buffer, size_t size, int err)
+static int selinux_inode_getsecurity(const struct inode *inode, const char *name, void *buffer, size_t size, int err)
 {
        struct inode_security_struct *isec = inode->i_security;