struct ocfs2_security_xattr_info {
        int enable;
-       char *name;
+       const char *name;
        void *value;
        size_t value_len;
 };
 
        int (*inode_alloc_security) (struct inode *inode);
        void (*inode_free_security) (struct inode *inode);
        int (*inode_init_security) (struct inode *inode, struct inode *dir,
-                                   const struct qstr *qstr, char **name,
+                                   const struct qstr *qstr, const char **name,
                                    void **value, size_t *len);
        int (*inode_create) (struct inode *dir,
                             struct dentry *dentry, umode_t mode);
                                 const struct qstr *qstr,
                                 initxattrs initxattrs, void *fs_data);
 int security_old_inode_init_security(struct inode *inode, struct inode *dir,
-                                    const struct qstr *qstr, char **name,
+                                    const struct qstr *qstr, const char **name,
                                     void **value, size_t *len);
 int security_inode_create(struct inode *dir, struct dentry *dentry, umode_t mode);
 int security_inode_link(struct dentry *old_dentry, struct inode *dir,
 static inline int security_old_inode_init_security(struct inode *inode,
                                                   struct inode *dir,
                                                   const struct qstr *qstr,
-                                                  char **name, void **value,
-                                                  size_t *len)
+                                                  const char **name,
+                                                  void **value, size_t *len)
 {
        return -EOPNOTSUPP;
 }
 
 };
 
 struct xattr {
-       char *name;
+       const char *name;
        void *value;
        size_t value_len;
 };
 
 };
 
 struct reiserfs_security_handle {
-       char *name;
+       const char *name;
        void *value;
        size_t length;
 };
 
 }
 
 static int cap_inode_init_security(struct inode *inode, struct inode *dir,
-                                  const struct qstr *qstr, char **name,
+                                  const struct qstr *qstr, const char **name,
                                   void **value, size_t *len)
 {
        return -EOPNOTSUPP;
 
 
        evm_xattr->value = xattr_data;
        evm_xattr->value_len = sizeof(*xattr_data);
-       evm_xattr->name = kstrdup(XATTR_EVM_SUFFIX, GFP_NOFS);
+       evm_xattr->name = XATTR_EVM_SUFFIX;
        return 0;
 out:
        kfree(xattr_data);
 
        if (unlikely(IS_PRIVATE(inode)))
                return 0;
 
-       memset(new_xattrs, 0, sizeof new_xattrs);
        if (!initxattrs)
                return security_ops->inode_init_security(inode, dir, qstr,
                                                         NULL, NULL, NULL);
+       memset(new_xattrs, 0, sizeof(new_xattrs));
        lsm_xattr = new_xattrs;
        ret = security_ops->inode_init_security(inode, dir, qstr,
                                                &lsm_xattr->name,
                goto out;
        ret = initxattrs(inode, new_xattrs, fs_data);
 out:
-       for (xattr = new_xattrs; xattr->name != NULL; xattr++) {
-               kfree(xattr->name);
+       for (xattr = new_xattrs; xattr->value != NULL; xattr++)
                kfree(xattr->value);
-       }
        return (ret == -EOPNOTSUPP) ? 0 : ret;
 }
 EXPORT_SYMBOL(security_inode_init_security);
 
 int security_old_inode_init_security(struct inode *inode, struct inode *dir,
-                                    const struct qstr *qstr, char **name,
+                                    const struct qstr *qstr, const char **name,
                                     void **value, size_t *len)
 {
        if (unlikely(IS_PRIVATE(inode)))
 
 }
 
 static int selinux_inode_init_security(struct inode *inode, struct inode *dir,
-                                      const struct qstr *qstr, char **name,
+                                      const struct qstr *qstr,
+                                      const char **name,
                                       void **value, size_t *len)
 {
        const struct task_security_struct *tsec = current_security();
        struct superblock_security_struct *sbsec;
        u32 sid, newsid, clen;
        int rc;
-       char *namep = NULL, *context;
+       char *context;
 
        dsec = dir->i_security;
        sbsec = dir->i_sb->s_security;
        if (!ss_initialized || !(sbsec->flags & SE_SBLABELSUPP))
                return -EOPNOTSUPP;
 
-       if (name) {
-               namep = kstrdup(XATTR_SELINUX_SUFFIX, GFP_NOFS);
-               if (!namep)
-                       return -ENOMEM;
-               *name = namep;
-       }
+       if (name)
+               *name = XATTR_SELINUX_SUFFIX;
 
        if (value && len) {
                rc = security_sid_to_context_force(newsid, &context, &clen);
-               if (rc) {
-                       kfree(namep);
+               if (rc)
                        return rc;
-               }
                *value = context;
                *len = clen;
        }
 
  * Returns 0 if it all works out, -ENOMEM if there's no memory
  */
 static int smack_inode_init_security(struct inode *inode, struct inode *dir,
-                                    const struct qstr *qstr, char **name,
+                                    const struct qstr *qstr, const char **name,
                                     void **value, size_t *len)
 {
        struct inode_smack *issp = inode->i_security;
        char *dsp = smk_of_inode(dir);
        int may;
 
-       if (name) {
-               *name = kstrdup(XATTR_SMACK_SUFFIX, GFP_NOFS);
-               if (*name == NULL)
-                       return -ENOMEM;
-       }
+       if (name)
+               *name = XATTR_SMACK_SUFFIX;
 
        if (value) {
                rcu_read_lock();