* [PATCH 00/15] lnfs: 3.8-rc6 release
@ 2013-02-08 12:39 ` Steve Dickson
0 siblings, 0 replies; 58+ messages in thread
From: Steve Dickson @ 2013-02-08 12:39 UTC (permalink / raw)
To: Trond Myklebust, J. Bruce Fields, David P. Quigley
Cc: Linux NFS list, Linux FS devel list, Linux Security List, SELinux List
From: Steve Dickson <steved-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org>
Here is the next release of the Label NFS code, forward ported to linux-3.8-rc6.
I've incorporated all of the code review comments (thank you for that time) with the exception of the following:
> Why not use the more common construct of defining
>
> struct nfs4_label {
> ....
> char label[NFS4_MAXLABELLEN];
> };
It makes things easier to keep label a pointer verses an array when it comes to initializing the structure (see _nfs4_get_security_label()), although I did
decrease NFS4_MAXLABELLEN to (4095 - offsetof(struct nfs4_label , label))
> + u32 attr_bitmask_nl[3];
> + /* V4 bitmask representing the
> + set of attributes supported
> + on this filesystem excluding
> + the label support bit. */
>
> Can't we just have attr_bitmask_nl point to attr_bitmask when not #ifdef
> CONFIG_NFS_V4_SECURITY_LABEL?
I'm thinking having both bitmasks makes it more obvious as to what is or is not
being used. I'm referring to the code in _nfs4_proc_getattr() and _nfs4_proc_lookup().
If the label is not set, use the non label bit mask verses hiding things behind
a pointer and not really knowing what bit mask is being used.
I also found and fixed a couple memory leaks...
The Fedora kernel rpms that have the patches are under
http://steved.fedorapeople.org/lnfs/kernels/
A wireshark rpm that can dissect the labels is under
http://steved.fedorapeople.org/lnfs/wireshark/
The actual patches from this release are under
http://steved.fedorapeople.org/lnfs/patches/lnfs-v3.8-rc6
Dave Quigley (3):
NFS:Add labels to client function prototypes
NFS: Add label lifecycle management
lnfs: Do not sleep holding the inode spin lock
David Quigley (10):
Security: Add hook to calculate context based on a negative dentry.
Security: Add Hook to test if the particular xattr is part of a MAC
model.
LSM: Add flags field to security_sb_set_mnt_opts for in kernel mount
data.
SELinux: Add new labeling type native labels
NFSv4: Add label recommended attribute and NFSv4 flags
NFSv4: Introduce new label structure
NFSv4: Extend fattr bitmaps to support all 3 words
NFS: Client implementation of Labeled-NFS
NFS: Extend NFS xattr handlers to accept the security namespace
NFSD: Server implementation of MAC Labeling
Steve Dickson (2):
Kconfig: Add Kconfig entry for Labeled NFS V4 client
Kconfig: Add Kconfig entry for Labeled NFS V4 server
fs/nfs/Kconfig | 18 ++
fs/nfs/client.c | 2 +-
fs/nfs/dir.c | 46 ++-
fs/nfs/getroot.c | 2 +-
fs/nfs/inode.c | 140 +++++++--
fs/nfs/namespace.c | 2 +-
fs/nfs/nfs3acl.c | 4 +-
fs/nfs/nfs3proc.c | 41 +--
fs/nfs/nfs4_fs.h | 8 +-
fs/nfs/nfs4namespace.c | 2 +-
fs/nfs/nfs4proc.c | 565 ++++++++++++++++++++++++++++++++----
fs/nfs/nfs4xdr.c | 199 ++++++++++---
fs/nfs/proc.c | 15 +-
fs/nfs/super.c | 17 +-
fs/nfsd/Kconfig | 16 +
fs/nfsd/nfs4proc.c | 41 +++
fs/nfsd/nfs4xdr.c | 116 +++++++-
fs/nfsd/nfsd.h | 8 +-
fs/nfsd/vfs.c | 30 ++
fs/nfsd/vfs.h | 2 +
fs/nfsd/xdr4.h | 3 +
include/linux/nfs4.h | 8 +
include/linux/nfs_fs.h | 29 +-
include/linux/nfs_fs_sb.h | 10 +-
include/linux/nfs_xdr.h | 30 +-
include/linux/security.h | 57 +++-
include/uapi/linux/nfs4.h | 2 +-
security/capability.c | 19 +-
security/security.c | 24 +-
security/selinux/hooks.c | 92 +++++-
security/selinux/include/security.h | 2 +
security/selinux/ss/policydb.c | 5 +-
security/smack/smack_lsm.c | 11 +
33 files changed, 1352 insertions(+), 214 deletions(-)
--
1.7.11.7
--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 58+ messages in thread
* [PATCH 00/15] lnfs: 3.8-rc6 release
@ 2013-02-08 12:39 ` Steve Dickson
0 siblings, 0 replies; 58+ messages in thread
From: Steve Dickson @ 2013-02-08 12:39 UTC (permalink / raw)
To: Trond Myklebust, J. Bruce Fields, David P. Quigley
Cc: Linux NFS list, Linux FS devel list, Linux Security List, SELinux List
From: Steve Dickson <steved@redhat.com>
Here is the next release of the Label NFS code, forward ported to linux-3.8-rc6.
I've incorporated all of the code review comments (thank you for that time) with the exception of the following:
> Why not use the more common construct of defining
>
> struct nfs4_label {
> ....
> char label[NFS4_MAXLABELLEN];
> };
It makes things easier to keep label a pointer verses an array when it comes to initializing the structure (see _nfs4_get_security_label()), although I did
decrease NFS4_MAXLABELLEN to (4095 - offsetof(struct nfs4_label , label))
> + u32 attr_bitmask_nl[3];
> + /* V4 bitmask representing the
> + set of attributes supported
> + on this filesystem excluding
> + the label support bit. */
>
> Can't we just have attr_bitmask_nl point to attr_bitmask when not #ifdef
> CONFIG_NFS_V4_SECURITY_LABEL?
I'm thinking having both bitmasks makes it more obvious as to what is or is not
being used. I'm referring to the code in _nfs4_proc_getattr() and _nfs4_proc_lookup().
If the label is not set, use the non label bit mask verses hiding things behind
a pointer and not really knowing what bit mask is being used.
I also found and fixed a couple memory leaks...
The Fedora kernel rpms that have the patches are under
http://steved.fedorapeople.org/lnfs/kernels/
A wireshark rpm that can dissect the labels is under
http://steved.fedorapeople.org/lnfs/wireshark/
The actual patches from this release are under
http://steved.fedorapeople.org/lnfs/patches/lnfs-v3.8-rc6
Dave Quigley (3):
NFS:Add labels to client function prototypes
NFS: Add label lifecycle management
lnfs: Do not sleep holding the inode spin lock
David Quigley (10):
Security: Add hook to calculate context based on a negative dentry.
Security: Add Hook to test if the particular xattr is part of a MAC
model.
LSM: Add flags field to security_sb_set_mnt_opts for in kernel mount
data.
SELinux: Add new labeling type native labels
NFSv4: Add label recommended attribute and NFSv4 flags
NFSv4: Introduce new label structure
NFSv4: Extend fattr bitmaps to support all 3 words
NFS: Client implementation of Labeled-NFS
NFS: Extend NFS xattr handlers to accept the security namespace
NFSD: Server implementation of MAC Labeling
Steve Dickson (2):
Kconfig: Add Kconfig entry for Labeled NFS V4 client
Kconfig: Add Kconfig entry for Labeled NFS V4 server
fs/nfs/Kconfig | 18 ++
fs/nfs/client.c | 2 +-
fs/nfs/dir.c | 46 ++-
fs/nfs/getroot.c | 2 +-
fs/nfs/inode.c | 140 +++++++--
fs/nfs/namespace.c | 2 +-
fs/nfs/nfs3acl.c | 4 +-
fs/nfs/nfs3proc.c | 41 +--
fs/nfs/nfs4_fs.h | 8 +-
fs/nfs/nfs4namespace.c | 2 +-
fs/nfs/nfs4proc.c | 565 ++++++++++++++++++++++++++++++++----
fs/nfs/nfs4xdr.c | 199 ++++++++++---
fs/nfs/proc.c | 15 +-
fs/nfs/super.c | 17 +-
fs/nfsd/Kconfig | 16 +
fs/nfsd/nfs4proc.c | 41 +++
fs/nfsd/nfs4xdr.c | 116 +++++++-
fs/nfsd/nfsd.h | 8 +-
fs/nfsd/vfs.c | 30 ++
fs/nfsd/vfs.h | 2 +
fs/nfsd/xdr4.h | 3 +
include/linux/nfs4.h | 8 +
include/linux/nfs_fs.h | 29 +-
include/linux/nfs_fs_sb.h | 10 +-
include/linux/nfs_xdr.h | 30 +-
include/linux/security.h | 57 +++-
include/uapi/linux/nfs4.h | 2 +-
security/capability.c | 19 +-
security/security.c | 24 +-
security/selinux/hooks.c | 92 +++++-
security/selinux/include/security.h | 2 +
security/selinux/ss/policydb.c | 5 +-
security/smack/smack_lsm.c | 11 +
33 files changed, 1352 insertions(+), 214 deletions(-)
--
1.7.11.7
^ permalink raw reply [flat|nested] 58+ messages in thread
* [PATCH 01/15] Security: Add hook to calculate context based on a negative dentry.
2013-02-08 12:39 ` Steve Dickson
(?)
@ 2013-02-08 12:39 ` Steve Dickson
-1 siblings, 0 replies; 58+ messages in thread
From: Steve Dickson @ 2013-02-08 12:39 UTC (permalink / raw)
To: Trond Myklebust, J. Bruce Fields, David P. Quigley
Cc: Linux NFS list, Linux FS devel list, Linux Security List, SELinux List
From: David Quigley <dpquigl@davequigley.com>
There is a time where we need to calculate a context without the
inode having been created yet. To do this we take the negative dentry and
calculate a context based on the process and the parent directory contexts.
Signed-off-by: Matthew N. Dodd <Matthew.Dodd@sparta.com>
Signed-off-by: Miguel Rodel Felipe <Rodel_FM@dsi.a-star.edu.sg>
Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene@dsi.a-star.edu.sg>
Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG@dsi.a-star.edu.sg>
---
include/linux/security.h | 27 +++++++++++++++++++++++++++
security/capability.c | 8 ++++++++
security/security.c | 10 ++++++++++
security/selinux/hooks.c | 35 +++++++++++++++++++++++++++++++++++
4 files changed, 80 insertions(+)
diff --git a/include/linux/security.h b/include/linux/security.h
index eee7478..a957e7a 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -26,6 +26,7 @@
#include <linux/capability.h>
#include <linux/slab.h>
#include <linux/err.h>
+#include <linux/string.h>
struct linux_binprm;
struct cred;
@@ -306,6 +307,15 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
* Parse a string of security data filling in the opts structure
* @options string containing all mount options known by the LSM
* @opts binary data structure usable by the LSM
+ * @dentry_init_security:
+ * Compute a context for a dentry as the inode is not yet available
+ * since NFSv4 has no label backed by an EA anyway.
+ * @dentry dentry to use in calculating the context.
+ * @mode mode used to determine resource type.
+ * @name name of the last path component used to create file
+ * @ctx pointer to place the pointer to the resulting context in.
+ * @ctxlen point to place the length of the resulting context.
+ *
*
* Security hooks for inode operations.
*
@@ -1439,6 +1449,10 @@ struct security_operations {
void (*sb_clone_mnt_opts) (const struct super_block *oldsb,
struct super_block *newsb);
int (*sb_parse_opts_str) (char *options, struct security_mnt_opts *opts);
+ int (*dentry_init_security) (struct dentry *dentry, int mode,
+ struct qstr *name, void **ctx,
+ u32 *ctxlen);
+
#ifdef CONFIG_SECURITY_PATH
int (*path_unlink) (struct path *dir, struct dentry *dentry);
@@ -1724,6 +1738,9 @@ int security_sb_set_mnt_opts(struct super_block *sb, struct security_mnt_opts *o
void security_sb_clone_mnt_opts(const struct super_block *oldsb,
struct super_block *newsb);
int security_sb_parse_opts_str(char *options, struct security_mnt_opts *opts);
+int security_dentry_init_security(struct dentry *dentry, int mode,
+ struct qstr *name, void **ctx,
+ u32 *ctxlen);
int security_inode_alloc(struct inode *inode);
void security_inode_free(struct inode *inode);
@@ -2028,6 +2045,16 @@ static inline int security_inode_alloc(struct inode *inode)
static inline void security_inode_free(struct inode *inode)
{ }
+static inline int security_dentry_init_security(struct dentry *dentry,
+ int mode,
+ struct qstr *name,
+ void **ctx,
+ u32 *ctxlen)
+{
+ return -EOPNOTSUPP;
+}
+
+
static inline int security_inode_init_security(struct inode *inode,
struct inode *dir,
const struct qstr *qstr,
diff --git a/security/capability.c b/security/capability.c
index 5797750..456bd9d 100644
--- a/security/capability.c
+++ b/security/capability.c
@@ -108,6 +108,13 @@ static int cap_sb_parse_opts_str(char *options, struct security_mnt_opts *opts)
return 0;
}
+static int cap_dentry_init_security(struct dentry *dentry, int mode,
+ struct qstr *name, void **ctx,
+ u32 *ctxlen)
+{
+ return 0;
+}
+
static int cap_inode_alloc_security(struct inode *inode)
{
return 0;
@@ -925,6 +932,7 @@ void __init security_fixup_ops(struct security_operations *ops)
set_to_cap_if_null(ops, sb_set_mnt_opts);
set_to_cap_if_null(ops, sb_clone_mnt_opts);
set_to_cap_if_null(ops, sb_parse_opts_str);
+ set_to_cap_if_null(ops, dentry_init_security);
set_to_cap_if_null(ops, inode_alloc_security);
set_to_cap_if_null(ops, inode_free_security);
set_to_cap_if_null(ops, inode_init_security);
diff --git a/security/security.c b/security/security.c
index 7b88c6a..723a10c 100644
--- a/security/security.c
+++ b/security/security.c
@@ -12,6 +12,7 @@
*/
#include <linux/capability.h>
+#include <linux/dcache.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
@@ -324,6 +325,15 @@ void security_inode_free(struct inode *inode)
security_ops->inode_free_security(inode);
}
+int security_dentry_init_security(struct dentry *dentry, int mode,
+ struct qstr *name, void **ctx,
+ u32 *ctxlen)
+{
+ return security_ops->dentry_init_security(dentry, mode, name,
+ ctx, ctxlen);
+}
+EXPORT_SYMBOL(security_dentry_init_security);
+
int security_inode_init_security(struct inode *inode, struct inode *dir,
const struct qstr *qstr,
const initxattrs initxattrs, void *fs_data)
diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index ef26e96..2664ed3 100644
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -2483,6 +2483,40 @@ static void selinux_inode_free_security(struct inode *inode)
inode_free_security(inode);
}
+static int selinux_dentry_init_security(struct dentry *dentry, int mode,
+ struct qstr *name, void **ctx,
+ u32 *ctxlen)
+{
+ const struct cred *cred = current_cred();
+ struct task_security_struct *tsec;
+ struct inode_security_struct *dsec;
+ struct superblock_security_struct *sbsec;
+ struct inode *dir = dentry->d_parent->d_inode;
+ u32 newsid;
+ int rc;
+
+ tsec = cred->security;
+ dsec = dir->i_security;
+ sbsec = dir->i_sb->s_security;
+
+ if (tsec->create_sid && sbsec->behavior != SECURITY_FS_USE_MNTPOINT) {
+ newsid = tsec->create_sid;
+ } else {
+ rc = security_transition_sid(tsec->sid, dsec->sid,
+ inode_mode_to_security_class(mode),
+ name,
+ &newsid);
+ if (rc) {
+ printk(KERN_WARNING
+ "%s: security_transition_sid failed, rc=%d\n",
+ __func__, -rc);
+ return rc;
+ }
+ }
+
+ return security_sid_to_context(newsid, (char **)ctx, ctxlen);
+}
+
static int selinux_inode_init_security(struct inode *inode, struct inode *dir,
const struct qstr *qstr, char **name,
void **value, size_t *len)
@@ -5534,6 +5568,7 @@ static struct security_operations selinux_ops = {
.sb_clone_mnt_opts = selinux_sb_clone_mnt_opts,
.sb_parse_opts_str = selinux_parse_opts_str,
+ .dentry_init_security = selinux_dentry_init_security,
.inode_alloc_security = selinux_inode_alloc_security,
.inode_free_security = selinux_inode_free_security,
--
1.7.11.7
^ permalink raw reply related [flat|nested] 58+ messages in thread
* [PATCH 02/15] Security: Add Hook to test if the particular xattr is part of a MAC model.
2013-02-08 12:39 ` Steve Dickson
(?)
(?)
@ 2013-02-08 12:39 ` Steve Dickson
-1 siblings, 0 replies; 58+ messages in thread
From: Steve Dickson @ 2013-02-08 12:39 UTC (permalink / raw)
To: Trond Myklebust, J. Bruce Fields, David P. Quigley
Cc: Linux NFS list, Linux FS devel list, Linux Security List, SELinux List
From: David Quigley <dpquigl@davequigley.com>
The interface to request security labels from user space is the xattr
interface. When requesting the security label from an NFS server it is
important to make sure the requested xattr actually is a MAC label. This allows
us to make sure that we get the desired semantics from the attribute instead of
something else such as capabilities or a time based LSM.
Signed-off-by: Matthew N. Dodd <Matthew.Dodd@sparta.com>
Signed-off-by: Miguel Rodel Felipe <Rodel_FM@dsi.a-star.edu.sg>
Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene@dsi.a-star.edu.sg>
Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG@dsi.a-star.edu.sg>
---
include/linux/security.h | 14 ++++++++++++++
security/capability.c | 6 ++++++
security/security.c | 6 ++++++
security/selinux/hooks.c | 6 ++++++
security/smack/smack_lsm.c | 11 +++++++++++
5 files changed, 43 insertions(+)
diff --git a/include/linux/security.h b/include/linux/security.h
index a957e7a..8a6faff 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -1319,6 +1319,13 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
* @pages contains the number of pages.
* Return 0 if permission is granted.
*
+ * @ismaclabel:
+ * Check if the extended attribute specified by @name
+ * represents a MAC label. Returns 0 if name is a MAC
+ * attribute otherwise returns non-zero.
+ * @name full extended attribute name to check against
+ * LSM as a MAC label.
+ *
* @secid_to_secctx:
* Convert secid to security context. If secdata is NULL the length of
* the result will be returned in seclen, but no secdata will be returned.
@@ -1600,6 +1607,7 @@ struct security_operations {
int (*getprocattr) (struct task_struct *p, char *name, char **value);
int (*setprocattr) (struct task_struct *p, char *name, void *value, size_t size);
+ int (*ismaclabel) (const char *name);
int (*secid_to_secctx) (u32 secid, char **secdata, u32 *seclen);
int (*secctx_to_secid) (const char *secdata, u32 seclen, u32 *secid);
void (*release_secctx) (char *secdata, u32 seclen);
@@ -1852,6 +1860,7 @@ void security_d_instantiate(struct dentry *dentry, struct inode *inode);
int security_getprocattr(struct task_struct *p, char *name, char **value);
int security_setprocattr(struct task_struct *p, char *name, void *value, size_t size);
int security_netlink_send(struct sock *sk, struct sk_buff *skb);
+int security_ismaclabel(const char *name);
int security_secid_to_secctx(u32 secid, char **secdata, u32 *seclen);
int security_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid);
void security_release_secctx(char *secdata, u32 seclen);
@@ -2540,6 +2549,11 @@ static inline int security_netlink_send(struct sock *sk, struct sk_buff *skb)
return cap_netlink_send(sk, skb);
}
+static inline int security_ismaclabel(const char *name)
+{
+ return 0;
+}
+
static inline int security_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
{
return -EOPNOTSUPP;
diff --git a/security/capability.c b/security/capability.c
index 456bd9d..07a6484 100644
--- a/security/capability.c
+++ b/security/capability.c
@@ -817,6 +817,11 @@ static int cap_setprocattr(struct task_struct *p, char *name, void *value,
return -EINVAL;
}
+static int cap_ismaclabel(const char *name)
+{
+ return 0;
+}
+
static int cap_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
{
return -EOPNOTSUPP;
@@ -1036,6 +1041,7 @@ void __init security_fixup_ops(struct security_operations *ops)
set_to_cap_if_null(ops, d_instantiate);
set_to_cap_if_null(ops, getprocattr);
set_to_cap_if_null(ops, setprocattr);
+ set_to_cap_if_null(ops, ismaclabel);
set_to_cap_if_null(ops, secid_to_secctx);
set_to_cap_if_null(ops, secctx_to_secid);
set_to_cap_if_null(ops, release_secctx);
diff --git a/security/security.c b/security/security.c
index 723a10c..6d7389c 100644
--- a/security/security.c
+++ b/security/security.c
@@ -1057,6 +1057,12 @@ int security_netlink_send(struct sock *sk, struct sk_buff *skb)
return security_ops->netlink_send(sk, skb);
}
+int security_ismaclabel(const char *name)
+{
+ return security_ops->ismaclabel(name);
+}
+EXPORT_SYMBOL(security_ismaclabel);
+
int security_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
{
return security_ops->secid_to_secctx(secid, secdata, seclen);
diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index 2664ed3..03659ab 100644
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -5426,6 +5426,11 @@ abort_change:
return error;
}
+static int selinux_ismaclabel(const char *name)
+{
+ return (strcmp(name, XATTR_SELINUX_SUFFIX) == 0);
+}
+
static int selinux_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
{
return security_sid_to_context(secid, secdata, seclen);
@@ -5664,6 +5669,7 @@ static struct security_operations selinux_ops = {
.getprocattr = selinux_getprocattr,
.setprocattr = selinux_setprocattr,
+ .ismaclabel = selinux_ismaclabel,
.secid_to_secctx = selinux_secid_to_secctx,
.secctx_to_secid = selinux_secctx_to_secid,
.release_secctx = selinux_release_secctx,
diff --git a/security/smack/smack_lsm.c b/security/smack/smack_lsm.c
index 38be92c..82c3c72 100644
--- a/security/smack/smack_lsm.c
+++ b/security/smack/smack_lsm.c
@@ -3335,6 +3335,16 @@ static void smack_audit_rule_free(void *vrule)
#endif /* CONFIG_AUDIT */
/**
+ * smack_ismaclabel - check if xattr @name references a smack MAC label
+ * @name: Full xattr name to check.
+ */
+static int smack_ismaclabel(const char *name)
+{
+ return (strcmp(name, XATTR_SMACK_SUFFIX) == 0);
+}
+
+
+/**
* smack_secid_to_secctx - return the smack label for a secid
* @secid: incoming integer
* @secdata: destination
@@ -3530,6 +3540,7 @@ struct security_operations smack_ops = {
.audit_rule_free = smack_audit_rule_free,
#endif /* CONFIG_AUDIT */
+ .ismaclabel = smack_ismaclabel,
.secid_to_secctx = smack_secid_to_secctx,
.secctx_to_secid = smack_secctx_to_secid,
.release_secctx = smack_release_secctx,
--
1.7.11.7
^ permalink raw reply related [flat|nested] 58+ messages in thread
* [PATCH 03/15] LSM: Add flags field to security_sb_set_mnt_opts for in kernel mount data.
2013-02-08 12:39 ` Steve Dickson
` (2 preceding siblings ...)
(?)
@ 2013-02-08 12:39 ` Steve Dickson
-1 siblings, 0 replies; 58+ messages in thread
From: Steve Dickson @ 2013-02-08 12:39 UTC (permalink / raw)
To: Trond Myklebust, J. Bruce Fields, David P. Quigley
Cc: Linux NFS list, Linux FS devel list, Linux Security List, SELinux List
From: David Quigley <dpquigl@davequigley.com>
There is no way to differentiate if a text mount option is passed from user
space or the kernel. A flags field is being added to the
security_sb_set_mnt_opts hook to allow for in kernel security flags to be sent
to the LSM for processing in addition to the text options received from mount.
This patch also updated existing code to fix compilation errors.
Signed-off-by: David P. Quigley <dpquigl@tycho.nsa.gov>
Signed-off-by: Miguel Rodel Felipe <Rodel_FM@dsi.a-star.edu.sg>
Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene@dsi.a-star.edu.sg>
Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG@dsi.a-star.edu.sg>
---
fs/nfs/super.c | 3 ++-
include/linux/security.h | 13 ++++++++++---
security/capability.c | 5 ++++-
security/security.c | 7 +++++--
security/selinux/hooks.c | 12 ++++++++++--
5 files changed, 31 insertions(+), 9 deletions(-)
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index b056b16..623c216 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -2418,7 +2418,8 @@ static int nfs_bdi_register(struct nfs_server *server)
int nfs_set_sb_security(struct super_block *s, struct dentry *mntroot,
struct nfs_mount_info *mount_info)
{
- return security_sb_set_mnt_opts(s, &mount_info->parsed->lsm_opts);
+ return security_sb_set_mnt_opts(s, &mount_info->parsed->lsm_opts,
+ 0, NULL);
}
EXPORT_SYMBOL_GPL(nfs_set_sb_security);
diff --git a/include/linux/security.h b/include/linux/security.h
index 8a6faff..5c4179a 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -1452,7 +1452,9 @@ struct security_operations {
int (*sb_pivotroot) (struct path *old_path,
struct path *new_path);
int (*sb_set_mnt_opts) (struct super_block *sb,
- struct security_mnt_opts *opts);
+ struct security_mnt_opts *opts,
+ unsigned long kern_flags,
+ unsigned long *set_kern_flags);
void (*sb_clone_mnt_opts) (const struct super_block *oldsb,
struct super_block *newsb);
int (*sb_parse_opts_str) (char *options, struct security_mnt_opts *opts);
@@ -1742,7 +1744,10 @@ int security_sb_mount(const char *dev_name, struct path *path,
const char *type, unsigned long flags, void *data);
int security_sb_umount(struct vfsmount *mnt, int flags);
int security_sb_pivotroot(struct path *old_path, struct path *new_path);
-int security_sb_set_mnt_opts(struct super_block *sb, struct security_mnt_opts *opts);
+int security_sb_set_mnt_opts(struct super_block *sb,
+ struct security_mnt_opts *opts,
+ unsigned long kern_flags,
+ unsigned long *set_kern_flags);
void security_sb_clone_mnt_opts(const struct super_block *oldsb,
struct super_block *newsb);
int security_sb_parse_opts_str(char *options, struct security_mnt_opts *opts);
@@ -2032,7 +2037,9 @@ static inline int security_sb_pivotroot(struct path *old_path,
}
static inline int security_sb_set_mnt_opts(struct super_block *sb,
- struct security_mnt_opts *opts)
+ struct security_mnt_opts *opts,
+ unsigned long kern_flags,
+ unsigned long *set_kern_flags)
{
return 0;
}
diff --git a/security/capability.c b/security/capability.c
index 07a6484..59b82d0 100644
--- a/security/capability.c
+++ b/security/capability.c
@@ -91,7 +91,10 @@ static int cap_sb_pivotroot(struct path *old_path, struct path *new_path)
}
static int cap_sb_set_mnt_opts(struct super_block *sb,
- struct security_mnt_opts *opts)
+ struct security_mnt_opts *opts,
+ unsigned long kern_flags,
+ unsigned long *set_kern_flags)
+
{
if (unlikely(opts->num_mnt_opts))
return -EOPNOTSUPP;
diff --git a/security/security.c b/security/security.c
index 6d7389c..dd9e4c8 100644
--- a/security/security.c
+++ b/security/security.c
@@ -294,9 +294,12 @@ int security_sb_pivotroot(struct path *old_path, struct path *new_path)
}
int security_sb_set_mnt_opts(struct super_block *sb,
- struct security_mnt_opts *opts)
+ struct security_mnt_opts *opts,
+ unsigned long kern_flags,
+ unsigned long *set_kern_flags)
{
- return security_ops->sb_set_mnt_opts(sb, opts);
+ return security_ops->sb_set_mnt_opts(sb, opts, kern_flags,
+ set_kern_flags);
}
EXPORT_SYMBOL(security_sb_set_mnt_opts);
diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index 03659ab..972db08 100644
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -551,7 +551,9 @@ static int bad_option(struct superblock_security_struct *sbsec, char flag,
* labeling information.
*/
static int selinux_set_mnt_opts(struct super_block *sb,
- struct security_mnt_opts *opts)
+ struct security_mnt_opts *opts,
+ unsigned long kern_flags,
+ unsigned long *set_kern_flags)
{
const struct cred *cred = current_cred();
int rc = 0, i;
@@ -579,6 +581,12 @@ static int selinux_set_mnt_opts(struct super_block *sb,
"before the security server is initialized\n");
goto out;
}
+ if (kern_flags && !set_kern_flags) {
+ /* Specifying internal flags without providing a place to
+ * place the results is not allowed */
+ rc = -EINVAL;
+ goto out;
+ }
/*
* Binary mount data FS will come through this function twice. Once
@@ -948,7 +956,7 @@ static int superblock_doinit(struct super_block *sb, void *data)
goto out_err;
out:
- rc = selinux_set_mnt_opts(sb, &opts);
+ rc = selinux_set_mnt_opts(sb, &opts, 0, NULL);
out_err:
security_free_mnt_opts(&opts);
--
1.7.11.7
^ permalink raw reply related [flat|nested] 58+ messages in thread
* [PATCH 04/15] SELinux: Add new labeling type native labels
2013-02-08 12:39 ` Steve Dickson
` (3 preceding siblings ...)
(?)
@ 2013-02-08 12:39 ` Steve Dickson
-1 siblings, 0 replies; 58+ messages in thread
From: Steve Dickson @ 2013-02-08 12:39 UTC (permalink / raw)
To: Trond Myklebust, J. Bruce Fields, David P. Quigley
Cc: Linux NFS list, Linux FS devel list, Linux Security List, SELinux List
From: David Quigley <dpquigl@davequigley.com>
There currently doesn't exist a labeling type that is adequate for use with
labeled NFS. Since NFS doesn't really support xattrs we can't use the use xattr
labeling behavior. For this we developed a new labeling type. The native
labeling type is used solely by NFS to ensure NFS inodes are labeled at runtime
by the NFS code instead of relying on the SELinux security server on the client
end.
Signed-off-by: Matthew N. Dodd <Matthew.Dodd@sparta.com>
Signed-off-by: Miguel Rodel Felipe <Rodel_FM@dsi.a-star.edu.sg>
Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene@dsi.a-star.edu.sg>
Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG@dsi.a-star.edu.sg>
---
include/linux/security.h | 3 +++
security/selinux/hooks.c | 35 ++++++++++++++++++++++++++---------
security/selinux/include/security.h | 2 ++
security/selinux/ss/policydb.c | 5 ++++-
4 files changed, 35 insertions(+), 10 deletions(-)
diff --git a/include/linux/security.h b/include/linux/security.h
index 5c4179a..9dc244e 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -61,6 +61,9 @@ struct mm_struct;
#define SECURITY_CAP_NOAUDIT 0
#define SECURITY_CAP_AUDIT 1
+/* LSM Agnostic defines for sb_set_mnt_opts */
+#define SECURITY_LSM_NATIVE_LABELS 1
+
struct ctl_table;
struct audit_krule;
struct user_namespace;
diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index 972db08..dda436f 100644
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -80,6 +80,7 @@
#include <linux/syslog.h>
#include <linux/user_namespace.h>
#include <linux/export.h>
+#include <linux/security.h>
#include <linux/msg.h>
#include <linux/shm.h>
@@ -283,13 +284,14 @@ static void superblock_free_security(struct super_block *sb)
/* The file system's label must be initialized prior to use. */
-static const char *labeling_behaviors[6] = {
+static const char *labeling_behaviors[7] = {
"uses xattr",
"uses transition SIDs",
"uses task SIDs",
"uses genfs_contexts",
"not configured for labeling",
"uses mountpoint labeling",
+ "uses native labeling",
};
static int inode_doinit_with_dentry(struct inode *inode, struct dentry *opt_dentry);
@@ -677,14 +679,21 @@ static int selinux_set_mnt_opts(struct super_block *sb,
if (strcmp(sb->s_type->name, "proc") == 0)
sbsec->flags |= SE_SBPROC;
- /* Determine the labeling behavior to use for this filesystem type. */
- rc = security_fs_use((sbsec->flags & SE_SBPROC) ? "proc" : sb->s_type->name, &sbsec->behavior, &sbsec->sid);
- if (rc) {
- printk(KERN_WARNING "%s: security_fs_use(%s) returned %d\n",
- __func__, sb->s_type->name, rc);
- goto out;
+ if (!sbsec->behavior) {
+ /*
+ * Determine the labeling behavior to use for this
+ * filesystem type.
+ */
+ rc = security_fs_use((sbsec->flags & SE_SBPROC) ?
+ "proc" : sb->s_type->name,
+ &sbsec->behavior, &sbsec->sid);
+ if (rc) {
+ printk(KERN_WARNING
+ "%s: security_fs_use(%s) returned %d\n",
+ __func__, sb->s_type->name, rc);
+ goto out;
+ }
}
-
/* sets the context of the superblock for the fs being mounted. */
if (fscontext_sid) {
rc = may_context_mount_sb_relabel(fscontext_sid, sbsec, cred);
@@ -699,6 +708,11 @@ static int selinux_set_mnt_opts(struct super_block *sb,
* sets the label used on all file below the mountpoint, and will set
* the superblock context if not already set.
*/
+ if (kern_flags & SECURITY_LSM_NATIVE_LABELS && !context_sid) {
+ sbsec->behavior = SECURITY_FS_USE_NATIVE;
+ *set_kern_flags |= SECURITY_LSM_NATIVE_LABELS;
+ }
+
if (context_sid) {
if (!fscontext_sid) {
rc = may_context_mount_sb_relabel(context_sid, sbsec,
@@ -730,7 +744,8 @@ static int selinux_set_mnt_opts(struct super_block *sb,
}
if (defcontext_sid) {
- if (sbsec->behavior != SECURITY_FS_USE_XATTR) {
+ if (sbsec->behavior != SECURITY_FS_USE_XATTR &&
+ sbsec->behavior != SECURITY_FS_USE_NATIVE) {
rc = -EINVAL;
printk(KERN_WARNING "SELinux: defcontext option is "
"invalid for this filesystem type\n");
@@ -1198,6 +1213,8 @@ static int inode_doinit_with_dentry(struct inode *inode, struct dentry *opt_dent
}
switch (sbsec->behavior) {
+ case SECURITY_FS_USE_NATIVE:
+ break;
case SECURITY_FS_USE_XATTR:
if (!inode->i_op->getxattr) {
isec->sid = sbsec->def_sid;
diff --git a/security/selinux/include/security.h b/security/selinux/include/security.h
index 6d38851..8fd8e18 100644
--- a/security/selinux/include/security.h
+++ b/security/selinux/include/security.h
@@ -169,6 +169,8 @@ int security_get_allow_unknown(void);
#define SECURITY_FS_USE_GENFS 4 /* use the genfs support */
#define SECURITY_FS_USE_NONE 5 /* no labeling support */
#define SECURITY_FS_USE_MNTPOINT 6 /* use mountpoint labeling */
+#define SECURITY_FS_USE_NATIVE 7 /* use native label support */
+#define SECURITY_FS_USE_MAX 7 /* Highest SECURITY_FS_USE_XXX */
int security_fs_use(const char *fstype, unsigned int *behavior,
u32 *sid);
diff --git a/security/selinux/ss/policydb.c b/security/selinux/ss/policydb.c
index 9cd9b7c..c8adde3 100644
--- a/security/selinux/ss/policydb.c
+++ b/security/selinux/ss/policydb.c
@@ -2168,7 +2168,10 @@ static int ocontext_read(struct policydb *p, struct policydb_compat_info *info,
rc = -EINVAL;
c->v.behavior = le32_to_cpu(buf[0]);
- if (c->v.behavior > SECURITY_FS_USE_NONE)
+ /* Determined at runtime, not in policy DB. */
+ if (c->v.behavior == SECURITY_FS_USE_MNTPOINT)
+ goto out;
+ if (c->v.behavior > SECURITY_FS_USE_MAX)
goto out;
rc = -ENOMEM;
--
1.7.11.7
^ permalink raw reply related [flat|nested] 58+ messages in thread
* [PATCH 05/15] NFSv4: Add label recommended attribute and NFSv4 flags
2013-02-08 12:39 ` Steve Dickson
` (4 preceding siblings ...)
(?)
@ 2013-02-08 12:39 ` Steve Dickson
-1 siblings, 0 replies; 58+ messages in thread
From: Steve Dickson @ 2013-02-08 12:39 UTC (permalink / raw)
To: Trond Myklebust, J. Bruce Fields, David P. Quigley
Cc: Linux NFS list, Linux FS devel list, Linux Security List, SELinux List
From: David Quigley <dpquigl@davequigley.com>
This patch adds several new flags to allow the NFS client and server to
determine if this attribute is supported and if it is being sent over the wire.
Signed-off-by: Matthew N. Dodd <Matthew.Dodd@sparta.com>
Signed-off-by: Miguel Rodel Felipe <Rodel_FM@dsi.a-star.edu.sg>
Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene@dsi.a-star.edu.sg>
Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG@dsi.a-star.edu.sg>
---
include/linux/nfs4.h | 1 +
include/linux/nfs_fs_sb.h | 1 +
include/linux/nfs_xdr.h | 4 +++-
3 files changed, 5 insertions(+), 1 deletion(-)
diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h
index e111fa4..f9235b4 100644
--- a/include/linux/nfs4.h
+++ b/include/linux/nfs4.h
@@ -373,6 +373,7 @@ enum lock_type4 {
#define FATTR4_WORD1_MOUNTED_ON_FILEID (1UL << 23)
#define FATTR4_WORD1_FS_LAYOUT_TYPES (1UL << 30)
#define FATTR4_WORD2_LAYOUT_BLKSIZE (1UL << 1)
+#define FATTR4_WORD2_SECURITY_LABEL (1UL << 17)
#define FATTR4_WORD2_MDSTHRESHOLD (1UL << 4)
/* MDS threshold bitmap bits */
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index 6c6ed15..d507357 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -197,5 +197,6 @@ struct nfs_server {
#define NFS_CAP_MTIME (1U << 13)
#define NFS_CAP_POSIX_LOCK (1U << 14)
#define NFS_CAP_UIDGID_NOMAP (1U << 15)
+#define NFS_CAP_SECURITY_LABEL (1U << 16)
#endif
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 29adb12..ac9ba69 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -104,6 +104,7 @@ struct nfs_fattr {
#define NFS_ATTR_FATTR_MOUNTED_ON_FILEID (1U << 22)
#define NFS_ATTR_FATTR_OWNER_NAME (1U << 23)
#define NFS_ATTR_FATTR_GROUP_NAME (1U << 24)
+#define NFS_ATTR_FATTR_V4_SECURITY_LABEL (1U << 25)
#define NFS_ATTR_FATTR (NFS_ATTR_FATTR_TYPE \
| NFS_ATTR_FATTR_MODE \
@@ -123,7 +124,8 @@ struct nfs_fattr {
#define NFS_ATTR_FATTR_V3 (NFS_ATTR_FATTR \
| NFS_ATTR_FATTR_SPACE_USED)
#define NFS_ATTR_FATTR_V4 (NFS_ATTR_FATTR \
- | NFS_ATTR_FATTR_SPACE_USED)
+ | NFS_ATTR_FATTR_SPACE_USED \
+ | NFS_ATTR_FATTR_V4_SECURITY_LABEL)
/*
* Info on the file system
--
1.7.11.7
^ permalink raw reply related [flat|nested] 58+ messages in thread
* [PATCH 06/15] NFSv4: Introduce new label structure
2013-02-08 12:39 ` Steve Dickson
` (5 preceding siblings ...)
(?)
@ 2013-02-08 12:39 ` Steve Dickson
2013-02-12 22:07 ` J. Bruce Fields
-1 siblings, 1 reply; 58+ messages in thread
From: Steve Dickson @ 2013-02-08 12:39 UTC (permalink / raw)
To: Trond Myklebust, J. Bruce Fields, David P. Quigley
Cc: Linux NFS list, Linux FS devel list, Linux Security List, SELinux List
From: David Quigley <dpquigl@davequigley.com>
In order to mimic the way that NFSv4 ACLs are implemented we have created a
structure to be used to pass label data up and down the call chain. This patch
adds the new structure and new members to the required NFSv4 call structures.
Signed-off-by: Matthew N. Dodd <Matthew.Dodd@sparta.com>
Signed-off-by: Miguel Rodel Felipe <Rodel_FM@dsi.a-star.edu.sg>
Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene@dsi.a-star.edu.sg>
Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG@dsi.a-star.edu.sg>
---
fs/nfs/inode.c | 33 +++++++++++++++++++++++++++++++++
include/linux/nfs4.h | 7 +++++++
include/linux/nfs_fs.h | 17 +++++++++++++++++
include/linux/nfs_xdr.h | 21 +++++++++++++++++++++
include/uapi/linux/nfs4.h | 2 +-
5 files changed, 79 insertions(+), 1 deletion(-)
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index ebeb94c..8d5f01b 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -255,6 +255,39 @@ nfs_init_locked(struct inode *inode, void *opaque)
return 0;
}
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags)
+{
+ struct nfs4_label *label = NULL;
+
+ if (!(server->caps & NFS_CAP_SECURITY_LABEL))
+ return label;
+
+ label = kzalloc(NFS4_MAXLABELLEN, flags);
+ if (label == NULL)
+ return ERR_PTR(-ENOMEM);
+
+ label->label = (char *)(label + 1);
+ label->len = NFS4_MAXLABELLEN;
+
+ return label;
+}
+EXPORT_SYMBOL_GPL(nfs4_label_alloc);
+
+void nfs4_label_init(struct nfs4_label *label)
+{
+ if (label && label->label) {
+ /* 0 is the null format meaning that the data is not
+ to be translated */
+ label->lfs = 0;
+ label->pi = 0;
+ label->len = NFS4_MAXLABELLEN;
+ }
+ return;
+}
+EXPORT_SYMBOL_GPL(nfs4_label_init);
+#endif
+
/*
* This is our front-end to iget that looks up inodes by file handle
* instead of inode number.
diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h
index f9235b4..aab8bd8 100644
--- a/include/linux/nfs4.h
+++ b/include/linux/nfs4.h
@@ -28,6 +28,13 @@ struct nfs4_acl {
struct nfs4_ace aces[0];
};
+struct nfs4_label {
+ uint32_t lfs;
+ uint32_t pi;
+ u32 len;
+ char *label;
+};
+
typedef struct { char data[NFS4_VERIFIER_SIZE]; } nfs4_verifier;
struct nfs_stateid4 {
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 1cc2568..1c55373 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -489,6 +489,23 @@ extern int nfs_mountpoint_expiry_timeout;
extern void nfs_release_automount_timer(void);
/*
+ * linux/fs/nfs/nfs4proc.c
+ */
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+extern struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags);
+extern void nfs4_label_init(struct nfs4_label *label);
+static inline void nfs4_label_free(struct nfs4_label *label)
+{
+ kfree(label);
+ return;
+}
+#else
+static inline struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags) { return NULL; }
+static inline void nfs4_label_init(void *label) {}
+static inline void nfs4_label_free(void *label) {}
+#endif
+
+/*
* linux/fs/nfs/unlink.c
*/
extern void nfs_complete_unlink(struct dentry *dentry, struct inode *);
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index ac9ba69..7e86290 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -350,6 +350,7 @@ struct nfs_openargs {
const u32 * bitmask;
const u32 * open_bitmap;
__u32 claim;
+ const struct nfs4_label *label;
};
struct nfs_openres {
@@ -359,6 +360,7 @@ struct nfs_openres {
struct nfs4_change_info cinfo;
__u32 rflags;
struct nfs_fattr * f_attr;
+ struct nfs4_label *f_label;
struct nfs_seqid * seqid;
const struct nfs_server *server;
fmode_t delegation_type;
@@ -403,6 +405,7 @@ struct nfs_closeres {
struct nfs4_sequence_res seq_res;
nfs4_stateid stateid;
struct nfs_fattr * fattr;
+ struct nfs4_label *label;
struct nfs_seqid * seqid;
const struct nfs_server *server;
};
@@ -476,6 +479,7 @@ struct nfs4_delegreturnargs {
struct nfs4_delegreturnres {
struct nfs4_sequence_res seq_res;
struct nfs_fattr * fattr;
+ struct nfs4_label *label;
const struct nfs_server *server;
};
@@ -496,6 +500,7 @@ struct nfs_readargs {
struct nfs_readres {
struct nfs4_sequence_res seq_res;
struct nfs_fattr * fattr;
+ struct nfs4_label *label;
__u32 count;
int eof;
};
@@ -564,6 +569,7 @@ struct nfs_removeres {
struct nfs4_sequence_res seq_res;
const struct nfs_server *server;
struct nfs_fattr *dir_attr;
+ struct nfs4_label *dir_label;
struct nfs4_change_info cinfo;
};
@@ -576,6 +582,8 @@ struct nfs_renameargs {
const struct nfs_fh *new_dir;
const struct qstr *old_name;
const struct qstr *new_name;
+ const struct nfs4_label *old_label;
+ const struct nfs4_label *new_label;
};
struct nfs_renameres {
@@ -583,8 +591,10 @@ struct nfs_renameres {
const struct nfs_server *server;
struct nfs4_change_info old_cinfo;
struct nfs_fattr *old_fattr;
+ struct nfs4_label *old_label;
struct nfs4_change_info new_cinfo;
struct nfs_fattr *new_fattr;
+ struct nfs4_label *new_label;
};
/*
@@ -599,6 +609,7 @@ struct nfs_entry {
int eof;
struct nfs_fh * fh;
struct nfs_fattr * fattr;
+ struct nfs4_label *label;
unsigned char d_type;
struct nfs_server * server;
};
@@ -631,6 +642,7 @@ struct nfs_setattrargs {
struct iattr * iap;
const struct nfs_server * server; /* Needed for name mapping */
const u32 * bitmask;
+ const struct nfs4_label *label;
};
struct nfs_setaclargs {
@@ -666,6 +678,7 @@ struct nfs_getaclres {
struct nfs_setattrres {
struct nfs4_sequence_res seq_res;
struct nfs_fattr * fattr;
+ struct nfs4_label *label;
const struct nfs_server * server;
};
@@ -711,6 +724,7 @@ struct nfs3_setaclargs {
struct nfs_diropok {
struct nfs_fh * fh;
struct nfs_fattr * fattr;
+ struct nfs4_label *label;
};
struct nfs_readlinkargs {
@@ -841,6 +855,7 @@ struct nfs4_accessres {
struct nfs4_sequence_res seq_res;
const struct nfs_server * server;
struct nfs_fattr * fattr;
+ struct nfs4_label *label;
u32 supported;
u32 access;
};
@@ -863,6 +878,7 @@ struct nfs4_create_arg {
const struct iattr * attrs;
const struct nfs_fh * dir_fh;
const u32 * bitmask;
+ const struct nfs4_label *label;
};
struct nfs4_create_res {
@@ -870,6 +886,7 @@ struct nfs4_create_res {
const struct nfs_server * server;
struct nfs_fh * fh;
struct nfs_fattr * fattr;
+ struct nfs4_label *label;
struct nfs4_change_info dir_cinfo;
};
@@ -894,6 +911,7 @@ struct nfs4_getattr_res {
struct nfs4_sequence_res seq_res;
const struct nfs_server * server;
struct nfs_fattr * fattr;
+ struct nfs4_label *label;
};
struct nfs4_link_arg {
@@ -908,8 +926,10 @@ struct nfs4_link_res {
struct nfs4_sequence_res seq_res;
const struct nfs_server * server;
struct nfs_fattr * fattr;
+ struct nfs4_label *label;
struct nfs4_change_info cinfo;
struct nfs_fattr * dir_attr;
+ struct nfs4_label *dir_label;
};
@@ -925,6 +945,7 @@ struct nfs4_lookup_res {
const struct nfs_server * server;
struct nfs_fattr * fattr;
struct nfs_fh * fh;
+ struct nfs4_label *label;
};
struct nfs4_lookup_root_arg {
diff --git a/include/uapi/linux/nfs4.h b/include/uapi/linux/nfs4.h
index 788128e..b8014a2 100644
--- a/include/uapi/linux/nfs4.h
+++ b/include/uapi/linux/nfs4.h
@@ -25,7 +25,7 @@
#define NFS4_MAXNAMLEN NAME_MAX
#define NFS4_OPAQUE_LIMIT 1024
#define NFS4_MAX_SESSIONID_LEN 16
-
+#define NFS4_MAXLABELLEN (4095 - offsetof(struct nfs4_label , label))
#define NFS4_ACCESS_READ 0x0001
#define NFS4_ACCESS_LOOKUP 0x0002
#define NFS4_ACCESS_MODIFY 0x0004
--
1.7.11.7
^ permalink raw reply related [flat|nested] 58+ messages in thread
* [PATCH 07/15] NFSv4: Extend fattr bitmaps to support all 3 words
2013-02-08 12:39 ` Steve Dickson
` (6 preceding siblings ...)
(?)
@ 2013-02-08 12:39 ` Steve Dickson
-1 siblings, 0 replies; 58+ messages in thread
From: Steve Dickson @ 2013-02-08 12:39 UTC (permalink / raw)
To: Trond Myklebust, J. Bruce Fields, David P. Quigley
Cc: Linux NFS list, Linux FS devel list, Linux Security List, SELinux List
From: David Quigley <dpquigl@davequigley.com>
The fattr handling bitmap code only uses the first two fattr words sofar. This
patch adds the 3rd word to being sent but doesn't populate it yet.
Signed-off-by: Miguel Rodel Felipe <Rodel_FM@dsi.a-star.edu.sg>
Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene@dsi.a-star.edu.sg>
Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG@dsi.a-star.edu.sg>
---
fs/nfs/nfs4_fs.h | 6 +++---
fs/nfs/nfs4proc.c | 10 +++++-----
fs/nfs/nfs4xdr.c | 20 ++++++++++++--------
fs/nfs/super.c | 1 +
include/linux/nfs_fs_sb.h | 2 +-
5 files changed, 22 insertions(+), 17 deletions(-)
diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h
index a3f488b..dfaee53 100644
--- a/fs/nfs/nfs4_fs.h
+++ b/fs/nfs/nfs4_fs.h
@@ -291,10 +291,10 @@ is_ds_client(struct nfs_client *clp)
extern const struct nfs4_minor_version_ops *nfs_v4_minor_ops[];
extern const u32 nfs4_fattr_bitmap[3];
-extern const u32 nfs4_statfs_bitmap[2];
-extern const u32 nfs4_pathconf_bitmap[2];
+extern const u32 nfs4_statfs_bitmap[3];
+extern const u32 nfs4_pathconf_bitmap[3];
extern const u32 nfs4_fsinfo_bitmap[3];
-extern const u32 nfs4_fs_locations_bitmap[2];
+extern const u32 nfs4_fs_locations_bitmap[3];
void nfs4_free_client(struct nfs_client *);
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index cf747ef..7723f8c 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -157,7 +157,7 @@ static const u32 nfs4_open_noattr_bitmap[3] = {
| FATTR4_WORD0_FILEID,
};
-const u32 nfs4_statfs_bitmap[2] = {
+const u32 nfs4_statfs_bitmap[3] = {
FATTR4_WORD0_FILES_AVAIL
| FATTR4_WORD0_FILES_FREE
| FATTR4_WORD0_FILES_TOTAL,
@@ -166,7 +166,7 @@ const u32 nfs4_statfs_bitmap[2] = {
| FATTR4_WORD1_SPACE_TOTAL
};
-const u32 nfs4_pathconf_bitmap[2] = {
+const u32 nfs4_pathconf_bitmap[3] = {
FATTR4_WORD0_MAXLINK
| FATTR4_WORD0_MAXNAME,
0
@@ -181,7 +181,7 @@ const u32 nfs4_fsinfo_bitmap[3] = { FATTR4_WORD0_MAXFILESIZE
FATTR4_WORD2_LAYOUT_BLKSIZE
};
-const u32 nfs4_fs_locations_bitmap[2] = {
+const u32 nfs4_fs_locations_bitmap[3] = {
FATTR4_WORD0_TYPE
| FATTR4_WORD0_CHANGE
| FATTR4_WORD0_SIZE
@@ -197,7 +197,7 @@ const u32 nfs4_fs_locations_bitmap[2] = {
| FATTR4_WORD1_TIME_ACCESS
| FATTR4_WORD1_TIME_METADATA
| FATTR4_WORD1_TIME_MODIFY
- | FATTR4_WORD1_MOUNTED_ON_FILEID
+ | FATTR4_WORD1_MOUNTED_ON_FILEID,
};
static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dentry,
@@ -5082,7 +5082,7 @@ static int _nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir,
struct page *page)
{
struct nfs_server *server = NFS_SERVER(dir);
- u32 bitmask[2] = {
+ u32 bitmask[3] = {
[0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
};
struct nfs4_fs_locations_arg args = {
diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index 26b1439..a9353d1 100644
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -983,15 +983,16 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const
int len;
uint32_t bmval0 = 0;
uint32_t bmval1 = 0;
+ uint32_t bmval2 = 0;
/*
* We reserve enough space to write the entire attribute buffer at once.
* In the worst-case, this would be
- * 12(bitmap) + 4(attrlen) + 8(size) + 4(mode) + 4(atime) + 4(mtime)
- * = 36 bytes, plus any contribution from variable-length fields
+ * 16(bitmap) + 4(attrlen) + 8(size) + 4(mode) + 4(atime) + 4(mtime)
+ * = 40 bytes, plus any contribution from variable-length fields
* such as owner/group.
*/
- len = 16;
+ len = 20;
/* Sigh */
if (iap->ia_valid & ATTR_SIZE)
@@ -1035,9 +1036,9 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const
* We write the bitmap length now, but leave the bitmap and the attribute
* buffer length to be backfilled at the end of this routine.
*/
- *p++ = cpu_to_be32(2);
+ *p++ = cpu_to_be32(3);
q = p;
- p += 3;
+ p += 4;
if (iap->ia_valid & ATTR_SIZE) {
bmval0 |= FATTR4_WORD0_SIZE;
@@ -1086,9 +1087,10 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const
len, ((char *)p - (char *)q) + 4);
BUG();
}
- len = (char *)p - (char *)q - 12;
+ len = (char *)p - (char *)q - 16;
*q++ = htonl(bmval0);
*q++ = htonl(bmval1);
+ *q++ = htonl(bmval2);
*q = htonl(len);
/* out: */
@@ -1194,8 +1196,10 @@ encode_getattr_three(struct xdr_stream *xdr,
static void encode_getfattr(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)
{
- encode_getattr_two(xdr, bitmask[0] & nfs4_fattr_bitmap[0],
- bitmask[1] & nfs4_fattr_bitmap[1], hdr);
+ encode_getattr_three(xdr, bitmask[0] & nfs4_fattr_bitmap[0],
+ bitmask[1] & nfs4_fattr_bitmap[1],
+ bitmask[2] & nfs4_fattr_bitmap[2],
+ hdr);
}
static void encode_getfattr_open(struct xdr_stream *xdr, const u32 *bitmask,
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index 623c216..c98b434 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -877,6 +877,7 @@ int nfs_show_stats(struct seq_file *m, struct dentry *root)
seq_printf(m, "\n\tnfsv4:\t");
seq_printf(m, "bm0=0x%x", nfss->attr_bitmask[0]);
seq_printf(m, ",bm1=0x%x", nfss->attr_bitmask[1]);
+ seq_printf(m, ",bm2=0x%x", nfss->attr_bitmask[2]);
seq_printf(m, ",acl=0x%x", nfss->acl_bitmask);
show_sessions(m, nfss);
show_pnfs(m, nfss);
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index d507357..e6ed3c2 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -145,7 +145,7 @@ struct nfs_server {
u32 attr_bitmask[3];/* V4 bitmask representing the set
of attributes supported on this
filesystem */
- u32 cache_consistency_bitmask[2];
+ u32 cache_consistency_bitmask[3];
/* V4 bitmask representing the subset
of change attribute, size, ctime
and mtime attributes supported by
--
1.7.11.7
^ permalink raw reply related [flat|nested] 58+ messages in thread
* [PATCH 08/15] NFS:Add labels to client function prototypes
2013-02-08 12:39 ` Steve Dickson
` (7 preceding siblings ...)
(?)
@ 2013-02-08 12:39 ` Steve Dickson
-1 siblings, 0 replies; 58+ messages in thread
From: Steve Dickson @ 2013-02-08 12:39 UTC (permalink / raw)
To: Trond Myklebust, J. Bruce Fields, David P. Quigley
Cc: Linux NFS list, Linux FS devel list, Linux Security List, SELinux List
From: Dave Quigley <dpquigl@taiga.selinuxproject.org>
>From David Quigley <dpquigl@davequigley.com>
After looking at all of the nfsv4 operations the label structure has been added
to the prototypes of the functions which can transmit label data.
Signed-off-by: Matthew N. Dodd <Matthew.Dodd@sparta.com>
Signed-off-by: Miguel Rodel Felipe <Rodel_FM@dsi.a-star.edu.sg>
Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene@dsi.a-star.edu.sg>
Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG@dsi.a-star.edu.sg>
---
fs/nfs/client.c | 2 +-
fs/nfs/dir.c | 23 +++++-----
fs/nfs/getroot.c | 2 +-
fs/nfs/inode.c | 33 +++++++-------
fs/nfs/namespace.c | 2 +-
fs/nfs/nfs3acl.c | 4 +-
fs/nfs/nfs3proc.c | 41 ++++++++---------
fs/nfs/nfs4_fs.h | 2 +-
fs/nfs/nfs4namespace.c | 2 +-
fs/nfs/nfs4proc.c | 117 +++++++++++++++++++++++++++++++-----------------
fs/nfs/proc.c | 15 ++++---
include/linux/nfs_fs.h | 9 ++--
include/linux/nfs_xdr.h | 5 ++-
13 files changed, 149 insertions(+), 108 deletions(-)
diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index 9f3c664..9798309 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -1075,7 +1075,7 @@ struct nfs_server *nfs_create_server(struct nfs_mount_info *mount_info,
}
if (!(fattr->valid & NFS_ATTR_FATTR)) {
- error = nfs_mod->rpc_ops->getattr(server, mount_info->mntfh, fattr);
+ error = nfs_mod->rpc_ops->getattr(server, mount_info->mntfh, fattr, NULL);
if (error < 0) {
dprintk("nfs_create_server: getattr error = %d\n", -error);
goto error;
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index 1b2d7eb..7003931 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -447,7 +447,7 @@ void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
dentry = d_lookup(parent, &filename);
if (dentry != NULL) {
if (nfs_same_file(dentry, entry)) {
- nfs_refresh_inode(dentry->d_inode, entry->fattr);
+ nfs_refresh_inode(dentry->d_inode, entry->fattr, entry->label);
goto out;
} else {
if (d_invalidate(dentry) != 0)
@@ -460,7 +460,7 @@ void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
if (dentry == NULL)
return;
- inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr);
+ inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr, entry->label);
if (IS_ERR(inode))
goto out;
@@ -1040,6 +1040,7 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
struct dentry *parent;
struct nfs_fh *fhandle = NULL;
struct nfs_fattr *fattr = NULL;
+ struct nfs4_label *label = NULL;
int error;
if (flags & LOOKUP_RCU)
@@ -1082,12 +1083,12 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
if (fhandle == NULL || fattr == NULL)
goto out_error;
- error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
+ error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, label);
if (error)
goto out_bad;
if (nfs_compare_fh(NFS_FH(inode), fhandle))
goto out_bad;
- if ((error = nfs_refresh_inode(inode, fattr)) != 0)
+ if ((error = nfs_refresh_inode(inode, fattr, label)) != 0)
goto out_bad;
nfs_free_fattr(fattr);
@@ -1216,6 +1217,7 @@ struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned in
struct inode *inode = NULL;
struct nfs_fh *fhandle = NULL;
struct nfs_fattr *fattr = NULL;
+ struct nfs4_label *label = NULL;
int error;
dfprintk(VFS, "NFS: lookup(%s/%s)\n",
@@ -1245,14 +1247,14 @@ struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned in
parent = dentry->d_parent;
/* Protect against concurrent sillydeletes */
nfs_block_sillyrename(parent);
- error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
+ error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, label);
if (error == -ENOENT)
goto no_entry;
if (error < 0) {
res = ERR_PTR(error);
goto out_unblock_sillyrename;
}
- inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
+ inode = nfs_fhget(dentry->d_sb, fhandle, fattr, label);
res = ERR_CAST(inode);
if (IS_ERR(res))
goto out_unblock_sillyrename;
@@ -1486,7 +1488,8 @@ no_open:
* Code common to create, mkdir, and mknod.
*/
int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
- struct nfs_fattr *fattr)
+ struct nfs_fattr *fattr,
+ struct nfs4_label *label)
{
struct dentry *parent = dget_parent(dentry);
struct inode *dir = parent->d_inode;
@@ -1499,18 +1502,18 @@ int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
if (dentry->d_inode)
goto out;
if (fhandle->size == 0) {
- error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr);
+ error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, NULL);
if (error)
goto out_error;
}
nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
if (!(fattr->valid & NFS_ATTR_FATTR)) {
struct nfs_server *server = NFS_SB(dentry->d_sb);
- error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr);
+ error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr, NULL);
if (error < 0)
goto out_error;
}
- inode = nfs_fhget(dentry->d_sb, fhandle, fattr);
+ inode = nfs_fhget(dentry->d_sb, fhandle, fattr, label);
error = PTR_ERR(inode);
if (IS_ERR(inode))
goto out_error;
diff --git a/fs/nfs/getroot.c b/fs/nfs/getroot.c
index 033803c..14bd667 100644
--- a/fs/nfs/getroot.c
+++ b/fs/nfs/getroot.c
@@ -95,7 +95,7 @@ struct dentry *nfs_get_root(struct super_block *sb, struct nfs_fh *mntfh,
goto out;
}
- inode = nfs_fhget(sb, mntfh, fsinfo.fattr);
+ inode = nfs_fhget(sb, mntfh, fsinfo.fattr, NULL);
if (IS_ERR(inode)) {
dprintk("nfs_get_root: get root inode failed\n");
ret = ERR_CAST(inode);
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 8d5f01b..6b315a0 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -61,7 +61,7 @@
static bool enable_ino64 = NFS_64_BIT_INODE_NUMBERS_ENABLED;
static void nfs_invalidate_inode(struct inode *);
-static int nfs_update_inode(struct inode *, struct nfs_fattr *);
+static int nfs_update_inode(struct inode *, struct nfs_fattr *, struct nfs4_label *);
static struct kmem_cache * nfs_inode_cachep;
@@ -293,7 +293,7 @@ EXPORT_SYMBOL_GPL(nfs4_label_init);
* instead of inode number.
*/
struct inode *
-nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
+nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr, struct nfs4_label *label)
{
struct nfs_find_desc desc = {
.fh = fh,
@@ -423,7 +423,7 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
unlock_new_inode(inode);
} else
- nfs_refresh_inode(inode, fattr);
+ nfs_refresh_inode(inode, fattr, label);
dprintk("NFS: nfs_fhget(%s/%Ld fh_crc=0x%08x ct=%d)\n",
inode->i_sb->s_id,
(long long)NFS_FILEID(inode),
@@ -480,7 +480,7 @@ nfs_setattr(struct dentry *dentry, struct iattr *attr)
NFS_PROTO(inode)->return_delegation(inode);
error = NFS_PROTO(inode)->setattr(dentry, fattr, attr);
if (error == 0)
- nfs_refresh_inode(inode, fattr);
+ nfs_refresh_inode(inode, fattr, NULL);
nfs_free_fattr(fattr);
out:
return error;
@@ -822,6 +822,7 @@ int
__nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
{
int status = -ESTALE;
+ struct nfs4_label *label = NULL;
struct nfs_fattr *fattr = NULL;
struct nfs_inode *nfsi = NFS_I(inode);
@@ -839,7 +840,7 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
goto out;
nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
- status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr);
+ status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr, label);
if (status != 0) {
dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n",
inode->i_sb->s_id,
@@ -852,7 +853,7 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
goto out;
}
- status = nfs_refresh_inode(inode, fattr);
+ status = nfs_refresh_inode(inode, fattr, label);
if (status) {
dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n",
inode->i_sb->s_id,
@@ -1209,10 +1210,10 @@ static int nfs_inode_attrs_need_update(const struct inode *inode, const struct n
((long)nfsi->attr_gencount - (long)nfs_read_attr_generation_counter() > 0);
}
-static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
+static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr, struct nfs4_label *label)
{
if (nfs_inode_attrs_need_update(inode, fattr))
- return nfs_update_inode(inode, fattr);
+ return nfs_update_inode(inode, fattr, label);
return nfs_check_inode_attributes(inode, fattr);
}
@@ -1226,21 +1227,21 @@ static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr
* safe to do a full update of the inode attributes, or whether just to
* call nfs_check_inode_attributes.
*/
-int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
+int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr, struct nfs4_label *label)
{
int status;
if ((fattr->valid & NFS_ATTR_FATTR) == 0)
return 0;
spin_lock(&inode->i_lock);
- status = nfs_refresh_inode_locked(inode, fattr);
+ status = nfs_refresh_inode_locked(inode, fattr, label);
spin_unlock(&inode->i_lock);
return status;
}
EXPORT_SYMBOL_GPL(nfs_refresh_inode);
-static int nfs_post_op_update_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
+static int nfs_post_op_update_inode_locked(struct inode *inode, struct nfs_fattr *fattr, struct nfs4_label *label)
{
struct nfs_inode *nfsi = NFS_I(inode);
@@ -1251,7 +1252,7 @@ static int nfs_post_op_update_inode_locked(struct inode *inode, struct nfs_fattr
}
if ((fattr->valid & NFS_ATTR_FATTR) == 0)
return 0;
- return nfs_refresh_inode_locked(inode, fattr);
+ return nfs_refresh_inode_locked(inode, fattr, label);
}
/**
@@ -1268,12 +1269,12 @@ static int nfs_post_op_update_inode_locked(struct inode *inode, struct nfs_fattr
* are expected to change one or more attributes, to avoid
* unnecessary NFS requests and trips through nfs_update_inode().
*/
-int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
+int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr, struct nfs4_label *label)
{
int status;
spin_lock(&inode->i_lock);
- status = nfs_post_op_update_inode_locked(inode, fattr);
+ status = nfs_post_op_update_inode_locked(inode, fattr, label);
spin_unlock(&inode->i_lock);
return status;
}
@@ -1325,7 +1326,7 @@ int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fa
fattr->valid |= NFS_ATTR_FATTR_PRESIZE;
}
out_noforce:
- status = nfs_post_op_update_inode_locked(inode, fattr);
+ status = nfs_post_op_update_inode_locked(inode, fattr, NULL);
spin_unlock(&inode->i_lock);
return status;
}
@@ -1343,7 +1344,7 @@ EXPORT_SYMBOL_GPL(nfs_post_op_update_inode_force_wcc);
*
* A very similar scenario holds for the dir cache.
*/
-static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
+static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr, struct nfs4_label *label)
{
struct nfs_server *server;
struct nfs_inode *nfsi = NFS_I(inode);
diff --git a/fs/nfs/namespace.c b/fs/nfs/namespace.c
index fc8dc20..348b535 100644
--- a/fs/nfs/namespace.c
+++ b/fs/nfs/namespace.c
@@ -280,7 +280,7 @@ struct vfsmount *nfs_submount(struct nfs_server *server, struct dentry *dentry,
struct dentry *parent = dget_parent(dentry);
/* Look it up again to get its attributes */
- err = server->nfs_client->rpc_ops->lookup(parent->d_inode, &dentry->d_name, fh, fattr);
+ err = server->nfs_client->rpc_ops->lookup(parent->d_inode, &dentry->d_name, fh, fattr, NULL);
dput(parent);
if (err != 0)
return ERR_PTR(err);
diff --git a/fs/nfs/nfs3acl.c b/fs/nfs/nfs3acl.c
index 4a1aafb..1a2f11b 100644
--- a/fs/nfs/nfs3acl.c
+++ b/fs/nfs/nfs3acl.c
@@ -240,7 +240,7 @@ struct posix_acl *nfs3_proc_getacl(struct inode *inode, int type)
switch (status) {
case 0:
- status = nfs_refresh_inode(inode, res.fattr);
+ status = nfs_refresh_inode(inode, res.fattr, NULL);
break;
case -EPFNOSUPPORT:
case -EPROTONOSUPPORT:
@@ -352,7 +352,7 @@ static int nfs3_proc_setacls(struct inode *inode, struct posix_acl *acl,
switch (status) {
case 0:
- status = nfs_refresh_inode(inode, fattr);
+ status = nfs_refresh_inode(inode, fattr, NULL);
nfs3_cache_acls(inode, acl, dfacl);
break;
case -EPFNOSUPPORT:
diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c
index 70efb63..69bca2f 100644
--- a/fs/nfs/nfs3proc.c
+++ b/fs/nfs/nfs3proc.c
@@ -98,7 +98,7 @@ nfs3_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
*/
static int
nfs3_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
- struct nfs_fattr *fattr)
+ struct nfs_fattr *fattr, struct nfs4_label *label)
{
struct rpc_message msg = {
.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR],
@@ -143,7 +143,8 @@ nfs3_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
static int
nfs3_proc_lookup(struct inode *dir, struct qstr *name,
- struct nfs_fh *fhandle, struct nfs_fattr *fattr)
+ struct nfs_fh *fhandle, struct nfs_fattr *fattr,
+ struct nfs4_label *label)
{
struct nfs3_diropargs arg = {
.fh = NFS_FH(dir),
@@ -168,7 +169,7 @@ nfs3_proc_lookup(struct inode *dir, struct qstr *name,
nfs_fattr_init(fattr);
status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
- nfs_refresh_inode(dir, res.dir_attr);
+ nfs_refresh_inode(dir, res.dir_attr, NULL);
if (status >= 0 && !(fattr->valid & NFS_ATTR_FATTR)) {
msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR];
msg.rpc_argp = fhandle;
@@ -216,7 +217,7 @@ static int nfs3_proc_access(struct inode *inode, struct nfs_access_entry *entry)
goto out;
status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
- nfs_refresh_inode(inode, res.fattr);
+ nfs_refresh_inode(inode, res.fattr, NULL);
if (status == 0) {
entry->mask = 0;
if (res.access & NFS3_ACCESS_READ)
@@ -255,7 +256,7 @@ static int nfs3_proc_readlink(struct inode *inode, struct page *page,
msg.rpc_resp = fattr;
status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
- nfs_refresh_inode(inode, fattr);
+ nfs_refresh_inode(inode, fattr, NULL);
nfs_free_fattr(fattr);
out:
dprintk("NFS reply readlink: %d\n", status);
@@ -298,9 +299,9 @@ static int nfs3_do_create(struct inode *dir, struct dentry *dentry, struct nfs3_
int status;
status = rpc_call_sync(NFS_CLIENT(dir), &data->msg, 0);
- nfs_post_op_update_inode(dir, data->res.dir_attr);
+ nfs_post_op_update_inode(dir, data->res.dir_attr, NULL);
if (status == 0)
- status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
+ status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
return status;
}
@@ -381,7 +382,7 @@ nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
* not sure this buys us anything (and I'd have
* to revamp the NFSv3 XDR code) */
status = nfs3_proc_setattr(dentry, data->res.fattr, sattr);
- nfs_post_op_update_inode(dentry->d_inode, data->res.fattr);
+ nfs_post_op_update_inode(dentry->d_inode, data->res.fattr, NULL);
dprintk("NFS reply setattr (post-create): %d\n", status);
if (status != 0)
goto out;
@@ -414,7 +415,7 @@ nfs3_proc_remove(struct inode *dir, struct qstr *name)
goto out;
status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
- nfs_post_op_update_inode(dir, res.dir_attr);
+ nfs_post_op_update_inode(dir, res.dir_attr, NULL);
nfs_free_fattr(res.dir_attr);
out:
dprintk("NFS reply remove: %d\n", status);
@@ -439,7 +440,7 @@ nfs3_proc_unlink_done(struct rpc_task *task, struct inode *dir)
if (nfs3_async_handle_jukebox(task, dir))
return 0;
res = task->tk_msg.rpc_resp;
- nfs_post_op_update_inode(dir, res->dir_attr);
+ nfs_post_op_update_inode(dir, res->dir_attr, NULL);
return 1;
}
@@ -464,8 +465,8 @@ nfs3_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
return 0;
res = task->tk_msg.rpc_resp;
- nfs_post_op_update_inode(old_dir, res->old_fattr);
- nfs_post_op_update_inode(new_dir, res->new_fattr);
+ nfs_post_op_update_inode(old_dir, res->old_fattr, NULL);
+ nfs_post_op_update_inode(new_dir, res->new_fattr, NULL);
return 1;
}
@@ -495,8 +496,8 @@ nfs3_proc_rename(struct inode *old_dir, struct qstr *old_name,
goto out;
status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0);
- nfs_post_op_update_inode(old_dir, res.old_fattr);
- nfs_post_op_update_inode(new_dir, res.new_fattr);
+ nfs_post_op_update_inode(old_dir, res.old_fattr, NULL);
+ nfs_post_op_update_inode(new_dir, res.new_fattr, NULL);
out:
nfs_free_fattr(res.old_fattr);
nfs_free_fattr(res.new_fattr);
@@ -528,8 +529,8 @@ nfs3_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
goto out;
status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
- nfs_post_op_update_inode(dir, res.dir_attr);
- nfs_post_op_update_inode(inode, res.fattr);
+ nfs_post_op_update_inode(dir, res.dir_attr, NULL);
+ nfs_post_op_update_inode(inode, res.fattr, NULL);
out:
nfs_free_fattr(res.dir_attr);
nfs_free_fattr(res.fattr);
@@ -622,7 +623,7 @@ nfs3_proc_rmdir(struct inode *dir, struct qstr *name)
msg.rpc_resp = dir_attr;
status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
- nfs_post_op_update_inode(dir, dir_attr);
+ nfs_post_op_update_inode(dir, dir_attr, NULL);
nfs_free_fattr(dir_attr);
out:
dprintk("NFS reply rmdir: %d\n", status);
@@ -677,7 +678,7 @@ nfs3_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
nfs_invalidate_atime(dir);
- nfs_refresh_inode(dir, res.dir_attr);
+ nfs_refresh_inode(dir, res.dir_attr, NULL);
nfs_free_fattr(res.dir_attr);
out:
@@ -816,7 +817,7 @@ static int nfs3_read_done(struct rpc_task *task, struct nfs_read_data *data)
return -EAGAIN;
nfs_invalidate_atime(inode);
- nfs_refresh_inode(inode, &data->fattr);
+ nfs_refresh_inode(inode, &data->fattr, NULL);
return 0;
}
@@ -860,7 +861,7 @@ static int nfs3_commit_done(struct rpc_task *task, struct nfs_commit_data *data)
{
if (nfs3_async_handle_jukebox(task, data->inode))
return -EAGAIN;
- nfs_refresh_inode(data->inode, data->res.fattr);
+ nfs_refresh_inode(data->inode, data->res.fattr, NULL);
return 0;
}
diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h
index dfaee53..5ae39be 100644
--- a/fs/nfs/nfs4_fs.h
+++ b/fs/nfs/nfs4_fs.h
@@ -225,7 +225,7 @@ extern int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fh
extern int nfs4_proc_fs_locations(struct rpc_clnt *, struct inode *, const struct qstr *,
struct nfs4_fs_locations *, struct page *);
extern struct rpc_clnt *nfs4_proc_lookup_mountpoint(struct inode *, struct qstr *,
- struct nfs_fh *, struct nfs_fattr *);
+ struct nfs_fh *, struct nfs_fattr *, struct nfs4_label *);
extern int nfs4_proc_secinfo(struct inode *, const struct qstr *, struct nfs4_secinfo_flavors *);
extern int nfs4_release_lockowner(struct nfs4_lock_state *);
extern const struct xattr_handler *nfs4_xattr_handlers[];
diff --git a/fs/nfs/nfs4namespace.c b/fs/nfs/nfs4namespace.c
index 1e09eb7..f5c701e 100644
--- a/fs/nfs/nfs4namespace.c
+++ b/fs/nfs/nfs4namespace.c
@@ -368,7 +368,7 @@ struct vfsmount *nfs4_submount(struct nfs_server *server, struct dentry *dentry,
struct vfsmount *mnt;
/* Look it up again to get its attributes and sec flavor */
- client = nfs4_proc_lookup_mountpoint(parent->d_inode, &dentry->d_name, fh, fattr);
+ client = nfs4_proc_lookup_mountpoint(parent->d_inode, &dentry->d_name, fh, fattr, NULL);
dput(parent);
if (IS_ERR(client))
return ERR_CAST(client);
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 7723f8c..4488373 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -77,11 +77,12 @@ static int _nfs4_recover_proc_open(struct nfs4_opendata *data);
static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *);
static int nfs4_async_handle_error(struct rpc_task *, const struct nfs_server *, struct nfs4_state *);
static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr);
-static int nfs4_proc_getattr(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *);
-static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr);
+static int nfs4_proc_getattr(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *, struct nfs4_label *label);
+static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr, struct nfs4_label *label);
static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
struct nfs_fattr *fattr, struct iattr *sattr,
- struct nfs4_state *state);
+ struct nfs4_state *state, struct nfs4_label *ilabel,
+ struct nfs4_label *olabel);
#ifdef CONFIG_NFS_V4_1
static int nfs41_test_stateid(struct nfs_server *, nfs4_stateid *);
static int nfs41_free_stateid(struct nfs_server *, nfs4_stateid *);
@@ -747,6 +748,7 @@ struct nfs4_opendata {
struct nfs4_string owner_name;
struct nfs4_string group_name;
struct nfs_fattr f_attr;
+ struct nfs4_label *f_label;
struct dentry *dir;
struct dentry *dentry;
struct nfs4_state_owner *owner;
@@ -762,6 +764,7 @@ struct nfs4_opendata {
static void nfs4_init_opendata_res(struct nfs4_opendata *p)
{
p->o_res.f_attr = &p->f_attr;
+ p->o_res.f_label = p->f_label;
p->o_res.seqid = p->o_arg.seqid;
p->c_res.seqid = p->c_arg.seqid;
p->o_res.server = p->o_arg.server;
@@ -772,7 +775,7 @@ static void nfs4_init_opendata_res(struct nfs4_opendata *p)
static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
struct nfs4_state_owner *sp, fmode_t fmode, int flags,
- const struct iattr *attrs,
+ const struct iattr *attrs, struct nfs4_label *label,
gfp_t gfp_mask)
{
struct dentry *parent = dget_parent(dentry);
@@ -810,6 +813,7 @@ static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
p->o_arg.bitmask = server->attr_bitmask;
p->o_arg.open_bitmap = &nfs4_fattr_bitmap[0];
p->o_arg.claim = NFS4_OPEN_CLAIM_NULL;
+ p->o_arg.label = label;
if (attrs != NULL && attrs->ia_valid != 0) {
__be32 verf[2];
@@ -1111,7 +1115,7 @@ _nfs4_opendata_reclaim_to_nfs4_state(struct nfs4_opendata *data)
if (state == NULL)
goto err;
- ret = nfs_refresh_inode(inode, &data->f_attr);
+ ret = nfs_refresh_inode(inode, &data->f_attr, data->f_label);
if (ret)
goto err;
@@ -1141,7 +1145,7 @@ _nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
ret = -EAGAIN;
if (!(data->f_attr.valid & NFS_ATTR_FATTR))
goto err;
- inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr);
+ inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr, data->f_label);
ret = PTR_ERR(inode);
if (IS_ERR(inode))
goto err;
@@ -1191,7 +1195,7 @@ static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context
{
struct nfs4_opendata *opendata;
- opendata = nfs4_opendata_alloc(ctx->dentry, state->owner, 0, 0, NULL, GFP_NOFS);
+ opendata = nfs4_opendata_alloc(ctx->dentry, state->owner, 0, 0, NULL, NULL, GFP_NOFS);
if (opendata == NULL)
return ERR_PTR(-ENOMEM);
opendata->state = state;
@@ -1694,7 +1698,7 @@ static int _nfs4_proc_open(struct nfs4_opendata *data)
return status;
}
if (!(o_res->f_attr->valid & NFS_ATTR_FATTR))
- _nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr);
+ _nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr, o_res->f_label);
return 0;
}
@@ -1853,6 +1857,7 @@ static int _nfs4_do_open(struct inode *dir,
fmode_t fmode,
int flags,
struct iattr *sattr,
+ struct nfs4_label *label,
struct rpc_cred *cred,
struct nfs4_state **res,
struct nfs4_threshold **ctx_th)
@@ -1861,6 +1866,7 @@ static int _nfs4_do_open(struct inode *dir,
struct nfs4_state *state = NULL;
struct nfs_server *server = NFS_SERVER(dir);
struct nfs4_opendata *opendata;
+ struct nfs4_label *olabel = NULL;
int status;
/* Protect against reboot recovery conflicts */
@@ -1876,7 +1882,7 @@ static int _nfs4_do_open(struct inode *dir,
if (dentry->d_inode != NULL)
nfs4_return_incompatible_delegation(dentry->d_inode, fmode);
status = -ENOMEM;
- opendata = nfs4_opendata_alloc(dentry, sp, fmode, flags, sattr, GFP_KERNEL);
+ opendata = nfs4_opendata_alloc(dentry, sp, fmode, flags, sattr, label, GFP_KERNEL);
if (opendata == NULL)
goto err_put_state_owner;
@@ -1910,10 +1916,11 @@ static int _nfs4_do_open(struct inode *dir,
nfs_fattr_init(opendata->o_res.f_attr);
status = nfs4_do_setattr(state->inode, cred,
opendata->o_res.f_attr, sattr,
- state);
- if (status == 0)
+ state, label, olabel);
+ if (status == 0) {
nfs_setattr_update_inode(state->inode, sattr);
- nfs_post_op_update_inode(state->inode, opendata->o_res.f_attr);
+ nfs_post_op_update_inode(state->inode, opendata->o_res.f_attr, olabel);
+ }
}
if (pnfs_use_threshold(ctx_th, opendata->f_attr.mdsthreshold, server))
@@ -1942,6 +1949,7 @@ static struct nfs4_state *nfs4_do_open(struct inode *dir,
fmode_t fmode,
int flags,
struct iattr *sattr,
+ struct nfs4_label *label,
struct rpc_cred *cred,
struct nfs4_threshold **ctx_th)
{
@@ -1951,7 +1959,7 @@ static struct nfs4_state *nfs4_do_open(struct inode *dir,
fmode &= FMODE_READ|FMODE_WRITE|FMODE_EXEC;
do {
- status = _nfs4_do_open(dir, dentry, fmode, flags, sattr, cred,
+ status = _nfs4_do_open(dir, dentry, fmode, flags, sattr, label, cred,
&res, ctx_th);
if (status == 0)
break;
@@ -1996,7 +2004,8 @@ static struct nfs4_state *nfs4_do_open(struct inode *dir,
static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
struct nfs_fattr *fattr, struct iattr *sattr,
- struct nfs4_state *state)
+ struct nfs4_state *state, struct nfs4_label *ilabel,
+ struct nfs4_label *olabel)
{
struct nfs_server *server = NFS_SERVER(inode);
struct nfs_setattrargs arg = {
@@ -2004,9 +2013,11 @@ static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
.iap = sattr,
.server = server,
.bitmask = server->attr_bitmask,
+ .label = ilabel,
};
struct nfs_setattrres res = {
.fattr = fattr,
+ .label = olabel,
.server = server,
};
struct rpc_message msg = {
@@ -2041,7 +2052,8 @@ static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
struct nfs_fattr *fattr, struct iattr *sattr,
- struct nfs4_state *state)
+ struct nfs4_state *state, struct nfs4_label *ilabel,
+ struct nfs4_label *olabel)
{
struct nfs_server *server = NFS_SERVER(inode);
struct nfs4_exception exception = {
@@ -2050,7 +2062,7 @@ static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
};
int err;
do {
- err = _nfs4_do_setattr(inode, cred, fattr, sattr, state);
+ err = _nfs4_do_setattr(inode, cred, fattr, sattr, state, ilabel, olabel);
switch (err) {
case -NFS4ERR_OPENMODE:
if (state && !(state->state & FMODE_WRITE)) {
@@ -2137,7 +2149,7 @@ static void nfs4_close_done(struct rpc_task *task, void *data)
rpc_restart_call_prepare(task);
}
nfs_release_seqid(calldata->arg.seqid);
- nfs_refresh_inode(calldata->inode, calldata->res.fattr);
+ nfs_refresh_inode(calldata->inode, calldata->res.fattr, NULL);
dprintk("%s: done, ret = %d!\n", __func__, task->tk_status);
}
@@ -2274,9 +2286,10 @@ static struct inode *
nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx, int open_flags, struct iattr *attr)
{
struct nfs4_state *state;
+ struct nfs4_label *label = NULL;
/* Protect against concurrent sillydeletes */
- state = nfs4_do_open(dir, ctx->dentry, ctx->mode, open_flags, attr,
+ state = nfs4_do_open(dir, ctx->dentry, ctx->mode, open_flags, attr, label,
ctx->cred, &ctx->mdsthreshold);
if (IS_ERR(state))
return ERR_CAST(state);
@@ -2475,6 +2488,7 @@ static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *mntfh,
{
int error;
struct nfs_fattr *fattr = info->fattr;
+ struct nfs4_label *label = NULL;
error = nfs4_server_capabilities(server, mntfh);
if (error < 0) {
@@ -2482,7 +2496,7 @@ static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *mntfh,
return error;
}
- error = nfs4_proc_getattr(server, mntfh, fattr);
+ error = nfs4_proc_getattr(server, mntfh, fattr, label);
if (error < 0) {
dprintk("nfs4_get_root: getattr error = %d\n", -error);
return error;
@@ -2538,7 +2552,8 @@ out:
return status;
}
-static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
+static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
+ struct nfs_fattr *fattr, struct nfs4_label *label)
{
struct nfs4_getattr_arg args = {
.fh = fhandle,
@@ -2546,6 +2561,7 @@ static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
};
struct nfs4_getattr_res res = {
.fattr = fattr,
+ .label = label,
.server = server,
};
struct rpc_message msg = {
@@ -2558,13 +2574,14 @@ static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
}
-static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
+static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
+ struct nfs_fattr *fattr, struct nfs4_label *label)
{
struct nfs4_exception exception = { };
int err;
do {
err = nfs4_handle_exception(server,
- _nfs4_proc_getattr(server, fhandle, fattr),
+ _nfs4_proc_getattr(server, fhandle, fattr, label),
&exception);
} while (exception.retry);
return err;
@@ -2620,7 +2637,7 @@ nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
}
}
- status = nfs4_do_setattr(inode, cred, fattr, sattr, state);
+ status = nfs4_do_setattr(inode, cred, fattr, sattr, state, NULL, NULL);
if (status == 0)
nfs_setattr_update_inode(inode, sattr);
return status;
@@ -2628,7 +2645,7 @@ nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir,
const struct qstr *name, struct nfs_fh *fhandle,
- struct nfs_fattr *fattr)
+ struct nfs_fattr *fattr, struct nfs4_label *label)
{
struct nfs_server *server = NFS_SERVER(dir);
int status;
@@ -2666,13 +2683,13 @@ static void nfs_fixup_secinfo_attributes(struct nfs_fattr *fattr)
static int nfs4_proc_lookup_common(struct rpc_clnt **clnt, struct inode *dir,
struct qstr *name, struct nfs_fh *fhandle,
- struct nfs_fattr *fattr)
+ struct nfs_fattr *fattr, struct nfs4_label *label)
{
struct nfs4_exception exception = { };
struct rpc_clnt *client = *clnt;
int err;
do {
- err = _nfs4_proc_lookup(client, dir, name, fhandle, fattr);
+ err = _nfs4_proc_lookup(client, dir, name, fhandle, fattr, label);
switch (err) {
case -NFS4ERR_BADNAME:
err = -ENOENT;
@@ -2706,12 +2723,13 @@ out:
}
static int nfs4_proc_lookup(struct inode *dir, struct qstr *name,
- struct nfs_fh *fhandle, struct nfs_fattr *fattr)
+ struct nfs_fh *fhandle, struct nfs_fattr *fattr,
+ struct nfs4_label *label)
{
int status;
struct rpc_clnt *client = NFS_CLIENT(dir);
- status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr);
+ status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr, label);
if (client != NFS_CLIENT(dir)) {
rpc_shutdown_client(client);
nfs_fixup_secinfo_attributes(fattr);
@@ -2721,12 +2739,13 @@ static int nfs4_proc_lookup(struct inode *dir, struct qstr *name,
struct rpc_clnt *
nfs4_proc_lookup_mountpoint(struct inode *dir, struct qstr *name,
- struct nfs_fh *fhandle, struct nfs_fattr *fattr)
+ struct nfs_fh *fhandle, struct nfs_fattr *fattr,
+ struct nfs4_label *label)
{
int status;
struct rpc_clnt *client = rpc_clone_client(NFS_CLIENT(dir));
- status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr);
+ status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr, label);
if (status < 0) {
rpc_shutdown_client(client);
return ERR_PTR(status);
@@ -2743,6 +2762,7 @@ static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry
};
struct nfs4_accessres res = {
.server = server,
+ .label = NULL,
};
struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS],
@@ -2777,7 +2797,7 @@ static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry
status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
if (!status) {
nfs_access_set_mask(entry, res.access);
- nfs_refresh_inode(inode, res.fattr);
+ nfs_refresh_inode(inode, res.fattr, res.label);
}
nfs_free_fattr(res.fattr);
return status;
@@ -2856,6 +2876,7 @@ static int
nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
int flags)
{
+ struct nfs4_label *ilabel = NULL;
struct nfs_open_context *ctx;
struct nfs4_state *state;
int status = 0;
@@ -2866,7 +2887,7 @@ nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
sattr->ia_mode &= ~current_umask();
state = nfs4_do_open(dir, dentry, ctx->mode,
- flags, sattr, ctx->cred,
+ flags, sattr, ilabel, ctx->cred,
&ctx->mdsthreshold);
d_drop(dentry);
if (IS_ERR(state)) {
@@ -2990,6 +3011,8 @@ static int _nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,
.new_dir = NFS_FH(new_dir),
.old_name = old_name,
.new_name = new_name,
+ .old_label = NULL,
+ .new_label = NULL,
};
struct nfs_renameres res = {
.server = server,
@@ -3034,6 +3057,7 @@ static int _nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *
};
struct nfs4_link_res res = {
.server = server,
+ .label = NULL,
};
struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK],
@@ -3049,7 +3073,7 @@ static int _nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *
status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
if (!status) {
update_changeattr(dir, &res.cinfo);
- nfs_post_op_update_inode(inode, res.fattr);
+ nfs_post_op_update_inode(inode, res.fattr, res.label);
}
out:
nfs_free_fattr(res.fattr);
@@ -3074,6 +3098,7 @@ struct nfs4_createdata {
struct nfs4_create_res res;
struct nfs_fh fh;
struct nfs_fattr fattr;
+ struct nfs4_label *label;
};
static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,
@@ -3097,6 +3122,7 @@ static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,
data->res.server = server;
data->res.fh = &data->fh;
data->res.fattr = &data->fattr;
+ data->res.label = data->label;
nfs_fattr_init(data->res.fattr);
}
return data;
@@ -3108,7 +3134,7 @@ static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_
&data->arg.seq_args, &data->res.seq_res, 1);
if (status == 0) {
update_changeattr(dir, &data->res.dir_cinfo);
- status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
+ status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, data->res.label);
}
return status;
}
@@ -3119,7 +3145,8 @@ static void nfs4_free_createdata(struct nfs4_createdata *data)
}
static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
- struct page *page, unsigned int len, struct iattr *sattr)
+ struct page *page, unsigned int len, struct iattr *sattr,
+ struct nfs4_label *label)
{
struct nfs4_createdata *data;
int status = -ENAMETOOLONG;
@@ -3135,6 +3162,7 @@ static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK];
data->arg.u.symlink.pages = &page;
data->arg.u.symlink.len = len;
+ data->arg.label = label;
status = nfs4_do_create(dir, dentry, data);
@@ -3147,18 +3175,19 @@ static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
struct page *page, unsigned int len, struct iattr *sattr)
{
struct nfs4_exception exception = { };
+ struct nfs4_label *label = NULL;
int err;
do {
err = nfs4_handle_exception(NFS_SERVER(dir),
_nfs4_proc_symlink(dir, dentry, page,
- len, sattr),
+ len, sattr, label),
&exception);
} while (exception.retry);
return err;
}
static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
- struct iattr *sattr)
+ struct iattr *sattr, struct nfs4_label *label)
{
struct nfs4_createdata *data;
int status = -ENOMEM;
@@ -3167,6 +3196,7 @@ static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
if (data == NULL)
goto out;
+ data->arg.label = label;
status = nfs4_do_create(dir, dentry, data);
nfs4_free_createdata(data);
@@ -3178,12 +3208,13 @@ static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
struct iattr *sattr)
{
struct nfs4_exception exception = { };
+ struct nfs4_label *label = NULL;
int err;
sattr->ia_mode &= ~current_umask();
do {
err = nfs4_handle_exception(NFS_SERVER(dir),
- _nfs4_proc_mkdir(dir, dentry, sattr),
+ _nfs4_proc_mkdir(dir, dentry, sattr, label),
&exception);
} while (exception.retry);
return err;
@@ -3243,7 +3274,7 @@ static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
}
static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
- struct iattr *sattr, dev_t rdev)
+ struct iattr *sattr, struct nfs4_label *label, dev_t rdev)
{
struct nfs4_createdata *data;
int mode = sattr->ia_mode;
@@ -3268,7 +3299,8 @@ static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
status = -EINVAL;
goto out_free;
}
-
+
+ data->arg.label = label;
status = nfs4_do_create(dir, dentry, data);
out_free:
nfs4_free_createdata(data);
@@ -3280,12 +3312,13 @@ static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
struct iattr *sattr, dev_t rdev)
{
struct nfs4_exception exception = { };
+ struct nfs4_label *label = NULL;
int err;
sattr->ia_mode &= ~current_umask();
do {
err = nfs4_handle_exception(NFS_SERVER(dir),
- _nfs4_proc_mknod(dir, dentry, sattr, rdev),
+ _nfs4_proc_mknod(dir, dentry, sattr, label, rdev),
&exception);
} while (exception.retry);
return err;
@@ -4240,7 +4273,7 @@ static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, co
if (status == 0)
nfs_post_op_update_inode_force_wcc(inode, &data->fattr);
else
- nfs_refresh_inode(inode, &data->fattr);
+ nfs_refresh_inode(inode, &data->fattr, NULL);
out:
rpc_put_task(task);
return status;
diff --git a/fs/nfs/proc.c b/fs/nfs/proc.c
index f084dac..0ee882e 100644
--- a/fs/nfs/proc.c
+++ b/fs/nfs/proc.c
@@ -98,7 +98,7 @@ nfs_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
*/
static int
nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
- struct nfs_fattr *fattr)
+ struct nfs_fattr *fattr, struct nfs4_label *label)
{
struct rpc_message msg = {
.rpc_proc = &nfs_procedures[NFSPROC_GETATTR],
@@ -146,7 +146,8 @@ nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
static int
nfs_proc_lookup(struct inode *dir, struct qstr *name,
- struct nfs_fh *fhandle, struct nfs_fattr *fattr)
+ struct nfs_fh *fhandle, struct nfs_fattr *fattr,
+ struct nfs4_label *label)
{
struct nfs_diropargs arg = {
.fh = NFS_FH(dir),
@@ -243,7 +244,7 @@ nfs_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
nfs_mark_for_revalidate(dir);
if (status == 0)
- status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
+ status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
nfs_free_createdata(data);
out:
dprintk("NFS reply create: %d\n", status);
@@ -290,7 +291,7 @@ nfs_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
}
if (status == 0)
- status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
+ status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
nfs_free_createdata(data);
out:
dprintk("NFS reply mknod: %d\n", status);
@@ -442,7 +443,7 @@ nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
* should fill in the data with a LOOKUP call on the wire.
*/
if (status == 0)
- status = nfs_instantiate(dentry, fh, fattr);
+ status = nfs_instantiate(dentry, fh, fattr, NULL);
out_free:
nfs_free_fattr(fattr);
@@ -471,7 +472,7 @@ nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
nfs_mark_for_revalidate(dir);
if (status == 0)
- status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
+ status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
nfs_free_createdata(data);
out:
dprintk("NFS reply mkdir: %d\n", status);
@@ -607,7 +608,7 @@ static int nfs_read_done(struct rpc_task *task, struct nfs_read_data *data)
nfs_invalidate_atime(inode);
if (task->tk_status >= 0) {
- nfs_refresh_inode(inode, data->res.fattr);
+ nfs_refresh_inode(inode, data->res.fattr, data->res.label);
/* Emulate the eof flag, which isn't normally needed in NFSv2
* as it is guaranteed to always return the file attributes
*/
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 1c55373..41b0b6d 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -328,9 +328,9 @@ extern void nfs_zap_mapping(struct inode *inode, struct address_space *mapping);
extern void nfs_zap_caches(struct inode *);
extern void nfs_invalidate_atime(struct inode *);
extern struct inode *nfs_fhget(struct super_block *, struct nfs_fh *,
- struct nfs_fattr *);
-extern int nfs_refresh_inode(struct inode *, struct nfs_fattr *);
-extern int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr);
+ struct nfs_fattr *, struct nfs4_label *);
+extern int nfs_refresh_inode(struct inode *, struct nfs_fattr *, struct nfs4_label *);
+extern int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr, struct nfs4_label *);
extern int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr);
extern int nfs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
extern void nfs_access_add_cache(struct inode *, struct nfs_access_entry *);
@@ -460,7 +460,8 @@ extern const struct file_operations nfs_dir_operations;
extern const struct dentry_operations nfs_dentry_operations;
extern void nfs_force_lookup_revalidate(struct inode *dir);
-extern int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fh, struct nfs_fattr *fattr);
+extern int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fh,
+ struct nfs_fattr *fattr, struct nfs4_label *label);
extern int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags);
extern void nfs_access_zap_cache(struct inode *inode);
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 7e86290..9f5f599 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -1399,11 +1399,12 @@ struct nfs_rpc_ops {
struct dentry *(*try_mount) (int, const char *, struct nfs_mount_info *,
struct nfs_subversion *);
int (*getattr) (struct nfs_server *, struct nfs_fh *,
- struct nfs_fattr *);
+ struct nfs_fattr *, struct nfs4_label *);
int (*setattr) (struct dentry *, struct nfs_fattr *,
struct iattr *);
int (*lookup) (struct inode *, struct qstr *,
- struct nfs_fh *, struct nfs_fattr *);
+ struct nfs_fh *, struct nfs_fattr *,
+ struct nfs4_label *);
int (*access) (struct inode *, struct nfs_access_entry *);
int (*readlink)(struct inode *, struct page *, unsigned int,
unsigned int);
--
1.7.11.7
^ permalink raw reply related [flat|nested] 58+ messages in thread
* [PATCH 09/15] NFS: Add label lifecycle management
2013-02-08 12:39 ` Steve Dickson
` (8 preceding siblings ...)
(?)
@ 2013-02-08 12:39 ` Steve Dickson
2013-02-12 22:27 ` J. Bruce Fields
-1 siblings, 1 reply; 58+ messages in thread
From: Steve Dickson @ 2013-02-08 12:39 UTC (permalink / raw)
To: Trond Myklebust, J. Bruce Fields, David P. Quigley
Cc: Linux NFS list, Linux FS devel list, Linux Security List, SELinux List
From: Dave Quigley <dpquigl@taiga.selinuxproject.org>
>From David Quigley <dpquigl@davequigley.com>
This patch adds the lifecycle management for the security label structure
introduced in an earlier patch. The label is not used yet but allocations and
freeing of the structure is handled.
Signed-off-by: Matthew N. Dodd <Matthew.Dodd@sparta.com>
Signed-off-by: Miguel Rodel Felipe <Rodel_FM@dsi.a-star.edu.sg>
Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene@dsi.a-star.edu.sg>
Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG@dsi.a-star.edu.sg>
---
fs/nfs/dir.c | 23 +++++++++++-
fs/nfs/inode.c | 15 ++++++--
fs/nfs/nfs4proc.c | 102 ++++++++++++++++++++++++++++++++++++++++++++++++++----
3 files changed, 129 insertions(+), 11 deletions(-)
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index 7003931..d81b7e3 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -585,10 +585,16 @@ int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page,
if (entry.fh == NULL || entry.fattr == NULL)
goto out;
+ entry.label = nfs4_label_alloc(NFS_SERVER(inode), GFP_NOWAIT);
+ if (IS_ERR(entry.label)) {
+ status = PTR_ERR(entry.label);
+ goto out;
+ }
+
array = nfs_readdir_get_array(page);
if (IS_ERR(array)) {
status = PTR_ERR(array);
- goto out;
+ goto out_label_free;
}
memset(array, 0, sizeof(struct nfs_cache_array));
array->eof_index = -1;
@@ -614,6 +620,8 @@ int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page,
nfs_readdir_free_large_page(pages_ptr, pages, array_size);
out_release_array:
nfs_readdir_release_array(page);
+out_label_free:
+ nfs4_label_free(entry.label);
out:
nfs_free_fattr(entry.fattr);
nfs_free_fhandle(entry.fh);
@@ -1083,6 +1091,10 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
if (fhandle == NULL || fattr == NULL)
goto out_error;
+ label = nfs4_label_alloc(NFS_SERVER(inode), GFP_NOWAIT);
+ if (IS_ERR(label))
+ goto out_error;
+
error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, label);
if (error)
goto out_bad;
@@ -1093,6 +1105,8 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
nfs_free_fattr(fattr);
nfs_free_fhandle(fhandle);
+ nfs4_label_free(label);
+
out_set_verifier:
nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
out_valid:
@@ -1109,6 +1123,7 @@ out_zap_parent:
out_bad:
nfs_free_fattr(fattr);
nfs_free_fhandle(fhandle);
+ nfs4_label_free(label);
nfs_mark_for_revalidate(dir);
if (inode && S_ISDIR(inode->i_mode)) {
/* Purge readdir caches. */
@@ -1129,6 +1144,7 @@ out_zap_parent:
out_error:
nfs_free_fattr(fattr);
nfs_free_fhandle(fhandle);
+ nfs4_label_free(label);
dput(parent);
dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) lookup returned error %d\n",
__func__, dentry->d_parent->d_name.name,
@@ -1244,6 +1260,10 @@ struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned in
if (fhandle == NULL || fattr == NULL)
goto out;
+ label = nfs4_label_alloc(NFS_SERVER(dir), GFP_NOWAIT);
+ if (IS_ERR(label))
+ goto out;
+
parent = dentry->d_parent;
/* Protect against concurrent sillydeletes */
nfs_block_sillyrename(parent);
@@ -1272,6 +1292,7 @@ no_entry:
nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
out_unblock_sillyrename:
nfs_unblock_sillyrename(parent);
+ nfs4_label_free(label);
out:
nfs_free_fattr(fattr);
nfs_free_fhandle(fhandle);
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 6b315a0..0cb67cf 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -840,6 +840,13 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
goto out;
nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
+
+ label = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
+ if (IS_ERR(label)) {
+ status = PTR_ERR(label);
+ goto out;
+ }
+
status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr, label);
if (status != 0) {
dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n",
@@ -850,7 +857,7 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
if (!S_ISDIR(inode->i_mode))
set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
}
- goto out;
+ goto err_out;
}
status = nfs_refresh_inode(inode, fattr, label);
@@ -858,7 +865,7 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n",
inode->i_sb->s_id,
(long long)NFS_FILEID(inode), status);
- goto out;
+ goto err_out;
}
if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
@@ -868,7 +875,9 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
inode->i_sb->s_id,
(long long)NFS_FILEID(inode));
- out:
+err_out:
+ nfs4_label_free(label);
+out:
nfs_free_fattr(fattr);
return status;
}
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 4488373..5c9233d1 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -786,9 +786,14 @@ static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
p = kzalloc(sizeof(*p), gfp_mask);
if (p == NULL)
goto err;
+
+ p->f_label = nfs4_label_alloc(server, gfp_mask);
+ if (IS_ERR(p->f_label))
+ goto err_free_p;
+
p->o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid, gfp_mask);
if (p->o_arg.seqid == NULL)
- goto err_free;
+ goto err_free_label;
nfs_sb_active(dentry->d_sb);
p->dentry = dget(dentry);
p->dir = parent;
@@ -831,7 +836,10 @@ static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
nfs4_init_opendata_res(p);
kref_init(&p->kref);
return p;
-err_free:
+
+err_free_label:
+ nfs4_label_free(p->f_label);
+err_free_p:
kfree(p);
err:
dput(parent);
@@ -848,6 +856,9 @@ static void nfs4_opendata_free(struct kref *kref)
if (p->state != NULL)
nfs4_put_open_state(p->state);
nfs4_put_state_owner(p->owner);
+
+ nfs4_label_free(p->f_label);
+
dput(p->dir);
dput(p->dentry);
nfs_sb_deactive(sb);
@@ -1886,6 +1897,14 @@ static int _nfs4_do_open(struct inode *dir,
if (opendata == NULL)
goto err_put_state_owner;
+ if (label) {
+ olabel = nfs4_label_alloc(server, GFP_KERNEL);
+ if (IS_ERR(olabel)) {
+ status = PTR_ERR(olabel);
+ goto err_opendata_put;
+ }
+ }
+
if (ctx_th && server->attr_bitmask[2] & FATTR4_WORD2_MDSTHRESHOLD) {
opendata->f_attr.mdsthreshold = pnfs_mdsthreshold_alloc();
if (!opendata->f_attr.mdsthreshold)
@@ -1897,18 +1916,18 @@ static int _nfs4_do_open(struct inode *dir,
status = _nfs4_proc_open(opendata);
if (status != 0)
- goto err_opendata_put;
+ goto err_free_label;
state = nfs4_opendata_to_nfs4_state(opendata);
status = PTR_ERR(state);
if (IS_ERR(state))
- goto err_opendata_put;
+ goto err_free_label;
if (server->caps & NFS_CAP_POSIX_LOCK)
set_bit(NFS_STATE_POSIX_LOCKS, &state->flags);
status = nfs4_opendata_access(cred, opendata, state, fmode, flags);
if (status != 0)
- goto err_opendata_put;
+ goto err_free_label;
if (opendata->o_arg.open_flags & O_EXCL) {
nfs4_exclusive_attrset(opendata, sattr);
@@ -1929,10 +1948,14 @@ static int _nfs4_do_open(struct inode *dir,
kfree(opendata->f_attr.mdsthreshold);
opendata->f_attr.mdsthreshold = NULL;
+ nfs4_label_free(olabel);
+
nfs4_opendata_put(opendata);
nfs4_put_state_owner(sp);
*res = state;
return 0;
+err_free_label:
+ nfs4_label_free(olabel);
err_opendata_put:
kfree(opendata->f_attr.mdsthreshold);
nfs4_opendata_put(opendata);
@@ -2496,16 +2519,23 @@ static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *mntfh,
return error;
}
+ label = nfs4_label_alloc(server, GFP_KERNEL);
+ if (IS_ERR(label))
+ return PTR_ERR(label);
+
error = nfs4_proc_getattr(server, mntfh, fattr, label);
if (error < 0) {
dprintk("nfs4_get_root: getattr error = %d\n", -error);
- return error;
+ goto err_free_label;
}
if (fattr->valid & NFS_ATTR_FATTR_FSID &&
!nfs_fsid_equal(&server->fsid, &fattr->fsid))
memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));
+err_free_label:
+ nfs4_label_free(label);
+
return error;
}
@@ -2611,6 +2641,7 @@ nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
struct inode *inode = dentry->d_inode;
struct rpc_cred *cred = NULL;
struct nfs4_state *state = NULL;
+ struct nfs4_label *label = NULL;
int status;
if (pnfs_ld_layoutret_on_setattr(inode))
@@ -2637,9 +2668,15 @@ nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
}
}
- status = nfs4_do_setattr(inode, cred, fattr, sattr, state, NULL, NULL);
+ label = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
+ if (IS_ERR(label))
+ return PTR_ERR(label);
+
+ status = nfs4_do_setattr(inode, cred, fattr, sattr, state, NULL, label);
if (status == 0)
nfs_setattr_update_inode(inode, sattr);
+
+ nfs4_label_free(label);
return status;
}
@@ -2794,11 +2831,21 @@ static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry
if (res.fattr == NULL)
return -ENOMEM;
+ res.label = nfs4_label_alloc(server, GFP_KERNEL);
+ if (IS_ERR(res.label)) {
+ status = PTR_ERR(res.label);
+ goto out;
+ }
+
status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
if (!status) {
nfs_access_set_mask(entry, res.access);
nfs_refresh_inode(inode, res.fattr, res.label);
}
+
+ nfs4_label_free(res.label);
+
+out:
nfs_free_fattr(res.fattr);
return status;
}
@@ -2922,6 +2969,7 @@ static int _nfs4_proc_remove(struct inode *dir, struct qstr *name)
status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1);
if (status == 0)
update_changeattr(dir, &res.cinfo);
+
return status;
}
@@ -2965,6 +3013,7 @@ static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir)
if (nfs4_async_handle_error(task, res->server, NULL) == -EAGAIN)
return 0;
update_changeattr(dir, &res->cinfo);
+
return 1;
}
@@ -3023,12 +3072,33 @@ static int _nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,
.rpc_resp = &res,
};
int status = -ENOMEM;
+
+
+ if (server->caps & NFS_CAP_SECURITY_LABEL) {
+ res.old_label = nfs4_label_alloc(server, GFP_NOWAIT);
+ if (IS_ERR(res.old_label)) {
+ status = PTR_ERR(res.old_label);
+ goto out;
+ }
+ res.new_label = nfs4_label_alloc(server, GFP_NOWAIT);
+ if (IS_ERR(res.new_label)) {
+ status = PTR_ERR(res.new_label);
+ nfs4_label_free(res.old_label);
+ goto out;
+ }
+ }
+
status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
if (!status) {
update_changeattr(old_dir, &res.old_cinfo);
update_changeattr(new_dir, &res.new_cinfo);
}
+
+ nfs4_label_free(res.old_label);
+ nfs4_label_free(res.new_label);
+
+out:
return status;
}
@@ -3070,11 +3140,21 @@ static int _nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *
if (res.fattr == NULL)
goto out;
+ res.label = nfs4_label_alloc(server, GFP_KERNEL);
+ if (IS_ERR(res.label)) {
+ status = PTR_ERR(res.label);
+ goto out;
+ }
+
status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
if (!status) {
update_changeattr(dir, &res.cinfo);
nfs_post_op_update_inode(inode, res.fattr, res.label);
}
+
+
+ nfs4_label_free(res.label);
+
out:
nfs_free_fattr(res.fattr);
return status;
@@ -3110,6 +3190,10 @@ static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,
if (data != NULL) {
struct nfs_server *server = NFS_SERVER(dir);
+ data->label = nfs4_label_alloc(server, GFP_KERNEL);
+ if (IS_ERR(data->label))
+ goto out_free;
+
data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE];
data->msg.rpc_argp = &data->arg;
data->msg.rpc_resp = &data->res;
@@ -3126,6 +3210,9 @@ static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,
nfs_fattr_init(data->res.fattr);
}
return data;
+out_free:
+ kfree(data);
+ return NULL;
}
static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data)
@@ -3141,6 +3228,7 @@ static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_
static void nfs4_free_createdata(struct nfs4_createdata *data)
{
+ nfs4_label_free(data->label);
kfree(data);
}
--
1.7.11.7
^ permalink raw reply related [flat|nested] 58+ messages in thread
* [PATCH 10/15] NFS: Client implementation of Labeled-NFS
2013-02-08 12:39 ` Steve Dickson
@ 2013-02-08 12:39 ` Steve Dickson
-1 siblings, 0 replies; 58+ messages in thread
From: Steve Dickson @ 2013-02-08 12:39 UTC (permalink / raw)
To: Trond Myklebust, J. Bruce Fields, David P. Quigley
Cc: Linux NFS list, Linux FS devel list, Linux Security List, SELinux List
From: David Quigley <dpquigl-a7DkhOHRHBuN9aS15agKxg@public.gmane.org>
This patch implements the client transport and handling support for labeled
NFS. The patch adds two functions to encode and decode the security label
recommended attribute which makes use of the LSM hooks added earlier. It also
adds code to grab the label from the file attribute structures and encode the
label to be sent back to the server.
Signed-off-by: Matthew N. Dodd <Matthew.Dodd-DABiIiYg7OfQT0dZR+AlfA@public.gmane.org>
Signed-off-by: Miguel Rodel Felipe <Rodel_FM-geVtEqcQUv4Eyxwt80+Gtti2O/JbrIOy@public.gmane.org>
Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene-geVtEqcQUv4Eyxwt80+Gtti2O/JbrIOy@public.gmane.org>
Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG-geVtEqcQUv4Eyxwt80+Gtti2O/JbrIOy@public.gmane.org>
---
fs/nfs/inode.c | 55 ++++++++-
fs/nfs/nfs4proc.c | 298 ++++++++++++++++++++++++++++++++++++++++++++--
fs/nfs/nfs4xdr.c | 179 ++++++++++++++++++++++------
fs/nfs/super.c | 17 ++-
include/linux/nfs_fs.h | 3 +
include/linux/nfs_fs_sb.h | 7 ++
security/selinux/hooks.c | 4 +
7 files changed, 507 insertions(+), 56 deletions(-)
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 0cb67cf..0d412c4 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -162,11 +162,19 @@ static void nfs_zap_caches_locked(struct inode *inode)
memset(NFS_I(inode)->cookieverf, 0, sizeof(NFS_I(inode)->cookieverf));
if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) {
- nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
nfs_fscache_invalidate(inode);
- } else {
- nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
- }
+ nfsi->cache_validity |= NFS_INO_INVALID_ATTR
+ | NFS_INO_INVALID_LABEL
+ | NFS_INO_INVALID_DATA
+ | NFS_INO_INVALID_ACCESS
+ | NFS_INO_INVALID_ACL
+ | NFS_INO_REVAL_PAGECACHE;
+ } else
+ nfsi->cache_validity |= NFS_INO_INVALID_ATTR
+ | NFS_INO_INVALID_LABEL
+ | NFS_INO_INVALID_ACCESS
+ | NFS_INO_INVALID_ACL
+ | NFS_INO_REVAL_PAGECACHE;
}
void nfs_zap_caches(struct inode *inode)
@@ -256,6 +264,24 @@ nfs_init_locked(struct inode *inode, void *opaque)
}
#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr,
+ struct nfs4_label *label)
+{
+ int error;
+
+ if ((fattr->valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL) &&
+ label && inode->i_security) {
+ error = security_inode_notifysecctx(inode, label->label,
+ label->len);
+ if (error)
+ printk(KERN_ERR "%s() %s %d "
+ "security_inode_notifysecctx() %d\n",
+ __func__,
+ (char *)label->label,
+ label->len, error);
+ }
+}
+
struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags)
{
struct nfs4_label *label = NULL;
@@ -286,7 +312,15 @@ void nfs4_label_init(struct nfs4_label *label)
return;
}
EXPORT_SYMBOL_GPL(nfs4_label_init);
+EXPORT_SYMBOL_GPL(nfs4_label_free);
+
+#else
+void inline nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr,
+ struct nfs4_label *label)
+{
+}
#endif
+EXPORT_SYMBOL_GPL(nfs_setsecurity);
/*
* This is our front-end to iget that looks up inodes by file handle
@@ -415,6 +449,9 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr, st
*/
inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
}
+
+ nfs_setsecurity(inode, fattr, label);
+
nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
nfsi->attrtimeo_timestamp = now;
nfsi->access_cache = RB_ROOT;
@@ -777,6 +814,7 @@ struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_c
spin_unlock(&inode->i_lock);
return ctx;
}
+EXPORT_SYMBOL_GPL(nfs_find_open_context);
static void nfs_file_clear_open_context(struct file *filp)
{
@@ -905,7 +943,8 @@ static int nfs_attribute_cache_expired(struct inode *inode)
*/
int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
{
- if (!(NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATTR)
+ if (!(NFS_I(inode)->cache_validity &
+ (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_LABEL))
&& !nfs_attribute_cache_expired(inode))
return NFS_STALE(inode) ? -ESTALE : 0;
return __nfs_revalidate_inode(server, inode);
@@ -1504,6 +1543,9 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr, struct
| NFS_INO_INVALID_ACL
| NFS_INO_REVAL_FORCED);
+ if (label && (server->caps & NFS_CAP_SECURITY_LABEL))
+ nfs_setsecurity(inode, fattr, label);
+
if (fattr->valid & NFS_ATTR_FATTR_NLINK) {
if (inode->i_nlink != fattr->nlink) {
invalid |= NFS_INO_INVALID_ATTR;
@@ -1525,7 +1567,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr, struct
inode->i_blocks = fattr->du.nfs2.blocks;
/* Update attrtimeo value if we're out of the unstable period */
- if (invalid & NFS_INO_INVALID_ATTR) {
+ if (invalid & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_LABEL)) {
nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
nfsi->attrtimeo_timestamp = now;
@@ -1538,6 +1580,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr, struct
}
}
invalid &= ~NFS_INO_INVALID_ATTR;
+ invalid &= ~NFS_INO_INVALID_LABEL;
/* Don't invalidate the data if we were to blame */
if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
|| S_ISLNK(inode->i_mode)))
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 5c9233d1..280bb22 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -87,6 +87,39 @@ static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
static int nfs41_test_stateid(struct nfs_server *, nfs4_stateid *);
static int nfs41_free_stateid(struct nfs_server *, nfs4_stateid *);
#endif
+
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+static inline struct nfs4_label *
+nfs4_label_init_security(struct inode *dir, struct dentry *dentry,
+ struct iattr *sattr, struct nfs4_label *l)
+{
+ int err;
+
+ if (nfs_server_capable(dir, NFS_CAP_SECURITY_LABEL)) {
+ err = security_dentry_init_security(dentry, sattr->ia_mode,
+ &dentry->d_name, (void **)&l->label, &l->len);
+ if (err == 0)
+ return l;
+ }
+ return NULL;
+}
+static inline void
+nfs4_label_release_security(struct nfs4_label *label)
+{
+ if (label)
+ security_release_secctx(label->label, label->len);
+}
+#else
+static inline struct nfs4_label *
+nfs4_label_init_security(struct inode *dir, struct dentry *dentry,
+ struct iattr *sattr, struct nfs4_label *l)
+{ return NULL; }
+
+static inline void
+nfs4_label_release_security(struct nfs4_label *label)
+{ return; }
+#endif
+
/* Prevent leaks of NFSv4 errors into userland */
static int nfs4_map_errors(int err)
{
@@ -131,7 +164,8 @@ const u32 nfs4_fattr_bitmap[3] = {
| FATTR4_WORD1_SPACE_USED
| FATTR4_WORD1_TIME_ACCESS
| FATTR4_WORD1_TIME_METADATA
- | FATTR4_WORD1_TIME_MODIFY
+ | FATTR4_WORD1_TIME_MODIFY,
+ FATTR4_WORD2_SECURITY_LABEL
};
static const u32 nfs4_pnfs_open_bitmap[3] = {
@@ -1939,6 +1973,7 @@ static int _nfs4_do_open(struct inode *dir,
if (status == 0) {
nfs_setattr_update_inode(state->inode, sattr);
nfs_post_op_update_inode(state->inode, opendata->o_res.f_attr, olabel);
+ nfs_setsecurity(state->inode, opendata->o_res.f_attr, olabel);
}
}
@@ -2052,6 +2087,9 @@ static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
unsigned long timestamp = jiffies;
int status;
+ if (ilabel == NULL || olabel == NULL)
+ arg.bitmask = server->attr_bitmask_nl;
+
nfs_fattr_init(fattr);
if (state != NULL) {
@@ -2279,7 +2317,7 @@ int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait)
if (calldata->arg.seqid == NULL)
goto out_free_calldata;
calldata->arg.fmode = 0;
- calldata->arg.bitmask = server->cache_consistency_bitmask;
+ calldata->arg.bitmask = server->cache_consistency_bitmask_nl;
calldata->res.fattr = &calldata->fattr;
calldata->res.seqid = calldata->arg.seqid;
calldata->res.server = server;
@@ -2309,11 +2347,16 @@ static struct inode *
nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx, int open_flags, struct iattr *attr)
{
struct nfs4_state *state;
- struct nfs4_label *label = NULL;
+ struct nfs4_label l, *label = NULL;
+
+ label = nfs4_label_init_security(dir, ctx->dentry, attr, &l);
/* Protect against concurrent sillydeletes */
state = nfs4_do_open(dir, ctx->dentry, ctx->mode, open_flags, attr, label,
ctx->cred, &ctx->mdsthreshold);
+
+ nfs4_label_release_security(label);
+
if (IS_ERR(state))
return ERR_CAST(state);
ctx->state = state;
@@ -2373,10 +2416,27 @@ static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *f
server->caps |= NFS_CAP_CTIME;
if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY)
server->caps |= NFS_CAP_MTIME;
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+ if (res.attr_bitmask[2] & FATTR4_WORD2_SECURITY_LABEL) {
+ server->caps |= NFS_CAP_SECURITY_LABEL;
+ } else
+#endif
+ server->attr_bitmask[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
+
+ if (server->caps & NFS_CAP_SECURITY_LABEL) {
+ memcpy(server->attr_bitmask_nl, res.attr_bitmask,
+ sizeof(server->attr_bitmask));
+ server->attr_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
+ }
memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask));
server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE;
- server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY;
+ server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA |
+ FATTR4_WORD1_TIME_MODIFY;
+ server->cache_consistency_bitmask[2] &= FATTR4_WORD2_SECURITY_LABEL;
+ memcpy(server->cache_consistency_bitmask_nl, server->cache_consistency_bitmask,
+ sizeof(server->cache_consistency_bitmask_nl));
+ server->cache_consistency_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
server->acl_bitmask = res.acl_bitmask;
server->fh_expire_type = res.fh_expire_type;
}
@@ -2399,8 +2459,9 @@ int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
struct nfs_fsinfo *info)
{
+ u32 bitmask[3];
struct nfs4_lookup_root_arg args = {
- .bitmask = nfs4_fattr_bitmap,
+ .bitmask = bitmask,
};
struct nfs4_lookup_res res = {
.server = server,
@@ -2413,6 +2474,13 @@ static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
.rpc_resp = &res,
};
+ bitmask[0] = nfs4_fattr_bitmap[0];
+ bitmask[1] = nfs4_fattr_bitmap[1];
+ /*
+ * Process the label in the upcoming getfattr
+ */
+ bitmask[2] = nfs4_fattr_bitmap[2] & ~FATTR4_WORD2_SECURITY_LABEL;
+
nfs_fattr_init(info->fattr);
return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
}
@@ -2599,7 +2667,10 @@ static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
.rpc_argp = &args,
.rpc_resp = &res,
};
-
+
+ if (!label)
+ args.bitmask = server->attr_bitmask_nl;
+
nfs_fattr_init(fattr);
return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
}
@@ -2694,6 +2765,7 @@ static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir,
struct nfs4_lookup_res res = {
.server = server,
.fattr = fattr,
+ .label = label,
.fh = fhandle,
};
struct rpc_message msg = {
@@ -2702,6 +2774,9 @@ static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir,
.rpc_resp = &res,
};
+ if (label == NULL)
+ args.bitmask = server->attr_bitmask_nl;
+
nfs_fattr_init(fattr);
dprintk("NFS call lookup %s\n", name->name);
@@ -2808,7 +2883,7 @@ static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry
.rpc_cred = entry->cred,
};
int mode = entry->mask;
- int status;
+ int status = 0;
/*
* Determine which access bits we want to ask for...
@@ -2923,7 +2998,7 @@ static int
nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
int flags)
{
- struct nfs4_label *ilabel = NULL;
+ struct nfs4_label l, *ilabel = NULL;
struct nfs_open_context *ctx;
struct nfs4_state *state;
int status = 0;
@@ -2932,6 +3007,8 @@ nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
if (IS_ERR(ctx))
return PTR_ERR(ctx);
+ ilabel = nfs4_label_init_security(dir, dentry, sattr, &l);
+
sattr->ia_mode &= ~current_umask();
state = nfs4_do_open(dir, dentry, ctx->mode,
flags, sattr, ilabel, ctx->cred,
@@ -2945,6 +3022,7 @@ nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
ctx->state = state;
out:
+ nfs4_label_release_security(ilabel);
put_nfs_open_context(ctx);
return status;
}
@@ -2994,6 +3072,8 @@ static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
res->server = server;
msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE];
nfs41_init_sequence(&args->seq_args, &res->seq_res, 1);
+
+ nfs_fattr_init(res->dir_attr);
}
static void nfs4_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
@@ -3263,14 +3343,19 @@ static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
struct page *page, unsigned int len, struct iattr *sattr)
{
struct nfs4_exception exception = { };
- struct nfs4_label *label = NULL;
+ struct nfs4_label l, *label = NULL;
int err;
+
+ label = nfs4_label_init_security(dir, dentry, sattr, &l);
+
do {
err = nfs4_handle_exception(NFS_SERVER(dir),
_nfs4_proc_symlink(dir, dentry, page,
len, sattr, label),
&exception);
} while (exception.retry);
+
+ nfs4_label_release_security(label);
return err;
}
@@ -3296,15 +3381,19 @@ static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
struct iattr *sattr)
{
struct nfs4_exception exception = { };
- struct nfs4_label *label = NULL;
+ struct nfs4_label l, *label = NULL;
int err;
+ label = nfs4_label_init_security(dir, dentry, sattr, &l);
+
sattr->ia_mode &= ~current_umask();
do {
err = nfs4_handle_exception(NFS_SERVER(dir),
_nfs4_proc_mkdir(dir, dentry, sattr, label),
&exception);
} while (exception.retry);
+ nfs4_label_release_security(label);
+
return err;
}
@@ -3320,7 +3409,9 @@ static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
.bitmask = NFS_SERVER(dentry->d_inode)->attr_bitmask,
.plus = plus,
};
- struct nfs4_readdir_res res;
+ struct nfs4_readdir_res res = {
+ .pgbase = 0,
+ };
struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR],
.rpc_argp = &args,
@@ -3400,15 +3491,20 @@ static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
struct iattr *sattr, dev_t rdev)
{
struct nfs4_exception exception = { };
- struct nfs4_label *label = NULL;
+ struct nfs4_label l, *label = NULL;
int err;
+ label = nfs4_label_init_security(dir, dentry, sattr, &l);
+
sattr->ia_mode &= ~current_umask();
do {
err = nfs4_handle_exception(NFS_SERVER(dir),
_nfs4_proc_mknod(dir, dentry, sattr, label, rdev),
&exception);
} while (exception.retry);
+
+ nfs4_label_release_security(label);
+
return err;
}
@@ -3624,7 +3720,11 @@ static void nfs4_proc_write_setup(struct nfs_write_data *data, struct rpc_messag
data->args.bitmask = NULL;
data->res.fattr = NULL;
} else
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+ data->args.bitmask = server->cache_consistency_bitmask_nl;
+#else
data->args.bitmask = server->cache_consistency_bitmask;
+#endif
if (!data->write_done_cb)
data->write_done_cb = nfs4_write_done_cb;
@@ -4049,6 +4149,178 @@ static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen
return err;
}
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+static int _nfs4_get_security_label(struct inode *inode, void *buf,
+ size_t buflen)
+{
+ struct nfs_server *server = NFS_SERVER(inode);
+ struct nfs_fattr fattr;
+ struct nfs4_label label = {0, 0, buflen, buf};
+ u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL };
+ struct nfs4_getattr_arg args = {
+ .fh = NFS_FH(inode),
+ .bitmask = bitmask,
+ };
+ struct nfs4_getattr_res res = {
+ .fattr = &fattr,
+ .label = &label,
+ .server = server,
+ };
+ struct rpc_message msg = {
+ .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
+ .rpc_argp = &args,
+ .rpc_resp = &res,
+ };
+ int ret;
+
+ nfs_fattr_init(&fattr);
+
+ ret = rpc_call_sync(server->client, &msg, 0);
+ if (ret)
+ return ret;
+ if (!(fattr.valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL))
+ return -ENOENT;
+ if (buflen < label.len)
+ return -ERANGE;
+ return 0;
+}
+
+static int nfs4_get_security_label(struct inode *inode, void *buf,
+ size_t buflen)
+{
+ struct nfs4_exception exception = { };
+ int err;
+
+ if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
+ return -EOPNOTSUPP;
+
+ do {
+ err = nfs4_handle_exception(NFS_SERVER(inode),
+ _nfs4_get_security_label(inode, buf, buflen),
+ &exception);
+ } while (exception.retry);
+ return err;
+}
+
+static int _nfs4_do_set_security_label(struct inode *inode,
+ struct nfs4_label *ilabel,
+ struct nfs_fattr *fattr,
+ struct nfs4_label *olabel,
+ struct nfs4_state *state)
+{
+
+ struct iattr sattr = {0};
+ struct nfs_server *server = NFS_SERVER(inode);
+ const u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL };
+ struct nfs_setattrargs args = {
+ .fh = NFS_FH(inode),
+ .iap = &sattr,
+ .server = server,
+ .bitmask = bitmask,
+ .label = ilabel,
+ };
+ struct nfs_setattrres res = {
+ .fattr = fattr,
+ .label = olabel,
+ .server = server,
+ };
+ struct rpc_message msg = {
+ .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
+ .rpc_argp = &args,
+ .rpc_resp = &res,
+ };
+ unsigned long timestamp = jiffies;
+ int status;
+
+ if (state != NULL) {
+ struct nfs_lockowner lockowner = {
+ .l_owner = current->files,
+ .l_pid = current->tgid,
+ };
+
+ msg.rpc_cred = state->owner->so_cred;
+ nfs4_select_rw_stateid(&args.stateid, state, FMODE_WRITE,
+ &lockowner);
+ } else if (nfs4_copy_delegation_stateid(&args.stateid, inode,
+ FMODE_WRITE)) {
+ /* Use that stateid */
+ } else
+ nfs4_stateid_copy(&args.stateid, &zero_stateid);
+
+ status = rpc_call_sync(server->client, &msg, 0);
+ if (status == 0 && state != NULL)
+ renew_lease(server, timestamp);
+ return status;
+}
+
+static int nfs4_do_set_security_label(struct inode *inode,
+ struct nfs4_label *ilabel,
+ struct nfs_fattr *fattr,
+ struct nfs4_label *olabel,
+ struct nfs4_state *state)
+{
+ struct nfs4_exception exception = { };
+ int err;
+
+ do {
+ err = nfs4_handle_exception(NFS_SERVER(inode),
+ _nfs4_do_set_security_label(inode, ilabel,
+ fattr, olabel, state),
+ &exception);
+ } while (exception.retry);
+ return err;
+}
+
+static int
+nfs4_set_security_label(struct dentry *dentry, const void *buf, size_t buflen)
+{
+ struct nfs4_label ilabel, *olabel = NULL;
+ struct nfs_fattr fattr;
+ struct rpc_cred *cred;
+ struct nfs_open_context *ctx;
+ struct nfs4_state *state = NULL;
+ struct inode *inode = dentry->d_inode;
+ int status;
+
+ if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
+ return -EOPNOTSUPP;
+
+ nfs_fattr_init(&fattr);
+
+ ilabel.pi = 0;
+ ilabel.lfs = 0;
+ ilabel.label = (char *)buf;
+ ilabel.len = buflen;
+
+ cred = rpc_lookup_cred();
+ if (IS_ERR(cred))
+ return PTR_ERR(cred);
+
+ olabel = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
+ if (IS_ERR(olabel)) {
+ status = -PTR_ERR(olabel);
+ goto out;
+ }
+
+ /* Search for an existing open(O_WRITE) file */
+ ctx = nfs_find_open_context(inode, cred, FMODE_WRITE);
+ if (ctx != NULL)
+ state = ctx->state;
+
+ status = nfs4_do_set_security_label(inode, &ilabel, &fattr, olabel,
+ state);
+ if (status == 0)
+ nfs_setsecurity(inode, &fattr, olabel);
+ if (ctx != NULL)
+ put_nfs_open_context(ctx);
+ nfs4_label_free(olabel);
+out:
+ put_rpccred(cred);
+ return status;
+}
+#endif /* CONFIG_NFS_V4_SECURITY_LABEL */
+
+
static int
nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server, struct nfs4_state *state)
{
@@ -4337,7 +4609,7 @@ static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, co
nfs41_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
data->args.fhandle = &data->fh;
data->args.stateid = &data->stateid;
- data->args.bitmask = server->cache_consistency_bitmask;
+ data->args.bitmask = server->cache_consistency_bitmask_nl;
nfs_copy_fh(&data->fh, NFS_FH(inode));
nfs4_stateid_copy(&data->stateid, stateid);
data->res.fattr = &data->fattr;
diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index a9353d1..3725433 100644
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -102,12 +102,23 @@ static int nfs4_stat_to_errno(int);
#define nfs4_path_maxsz (1 + ((3 + NFS4_MAXPATHLEN) >> 2))
#define nfs4_owner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
#define nfs4_group_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+/* PI(4 bytes) + LFS(4 bytes) + 1(for null terminator?) + MAXLABELLEN */
+#define nfs4_label_maxsz (4 + 4 + 1 + XDR_QUADLEN(NFS4_MAXLABELLEN))
+#define encode_readdir_space 24
+#define encode_readdir_bitmask_sz 3
+#else
+#define nfs4_label_maxsz 0
+#define encode_readdir_space 20
+#define encode_readdir_bitmask_sz 2
+#endif
/* We support only one layout type per file system */
#define decode_mdsthreshold_maxsz (1 + 1 + nfs4_fattr_bitmap_maxsz + 1 + 8)
/* This is based on getfattr, which uses the most attributes: */
#define nfs4_fattr_value_maxsz (1 + (1 + 2 + 2 + 4 + 2 + 1 + 1 + 2 + 2 + \
3 + 3 + 3 + nfs4_owner_maxsz + \
- nfs4_group_maxsz + decode_mdsthreshold_maxsz))
+ nfs4_group_maxsz + nfs4_label_maxsz + \
+ decode_mdsthreshold_maxsz))
#define nfs4_fattr_maxsz (nfs4_fattr_bitmap_maxsz + \
nfs4_fattr_value_maxsz)
#define decode_getattr_maxsz (op_decode_hdr_maxsz + nfs4_fattr_maxsz)
@@ -115,6 +126,7 @@ static int nfs4_stat_to_errno(int);
1 + 2 + 1 + \
nfs4_owner_maxsz + \
nfs4_group_maxsz + \
+ nfs4_label_maxsz + \
4 + 4)
#define encode_savefh_maxsz (op_encode_hdr_maxsz)
#define decode_savefh_maxsz (op_decode_hdr_maxsz)
@@ -192,9 +204,11 @@ static int nfs4_stat_to_errno(int);
encode_stateid_maxsz + 3)
#define decode_read_maxsz (op_decode_hdr_maxsz + 2)
#define encode_readdir_maxsz (op_encode_hdr_maxsz + \
- 2 + encode_verifier_maxsz + 5)
+ 2 + encode_verifier_maxsz + 5 + \
+ nfs4_label_maxsz)
#define decode_readdir_maxsz (op_decode_hdr_maxsz + \
- decode_verifier_maxsz)
+ decode_verifier_maxsz + \
+ nfs4_label_maxsz + nfs4_fattr_maxsz)
#define encode_readlink_maxsz (op_encode_hdr_maxsz)
#define decode_readlink_maxsz (op_decode_hdr_maxsz + 1)
#define encode_write_maxsz (op_encode_hdr_maxsz + \
@@ -972,7 +986,9 @@ static void encode_nfs4_verifier(struct xdr_stream *xdr, const nfs4_verifier *ve
encode_opaque_fixed(xdr, verf->data, NFS4_VERIFIER_SIZE);
}
-static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const struct nfs_server *server)
+static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap,
+ const struct nfs4_label *label,
+ const struct nfs_server *server)
{
char owner_name[IDMAP_NAMESZ];
char owner_group[IDMAP_NAMESZ];
@@ -1022,6 +1038,8 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const
}
len += 4 + (XDR_QUADLEN(owner_grouplen) << 2);
}
+ if (label)
+ len += 4 + 4 + 4 + (XDR_QUADLEN(label->len) << 2);
if (iap->ia_valid & ATTR_ATIME_SET)
len += 16;
else if (iap->ia_valid & ATTR_ATIME)
@@ -1078,6 +1096,13 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const
bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET;
*p++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME);
}
+ if (label) {
+ bmval2 |= FATTR4_WORD2_SECURITY_LABEL;
+ *p++ = cpu_to_be32(label->lfs);
+ *p++ = cpu_to_be32(label->pi);
+ *p++ = cpu_to_be32(label->len);
+ p = xdr_encode_opaque_fixed(p, label->label, label->len);
+ }
/*
* Now we backfill the bitmap and the attribute buffer length.
@@ -1144,7 +1169,7 @@ static void encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg *
}
encode_string(xdr, create->name->len, create->name->name);
- encode_attrs(xdr, create->attrs, create->server);
+ encode_attrs(xdr, create->attrs, create->label, create->server);
}
static void encode_getattr_one(struct xdr_stream *xdr, uint32_t bitmap, struct compound_hdr *hdr)
@@ -1377,21 +1402,23 @@ static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_op
switch(arg->open_flags & O_EXCL) {
case 0:
*p = cpu_to_be32(NFS4_CREATE_UNCHECKED);
- encode_attrs(xdr, arg->u.attrs, arg->server);
+ encode_attrs(xdr, arg->u.attrs, arg->label, arg->server);
break;
default:
clp = arg->server->nfs_client;
if (clp->cl_mvops->minor_version > 0) {
if (nfs4_has_persistent_session(clp)) {
*p = cpu_to_be32(NFS4_CREATE_GUARDED);
- encode_attrs(xdr, arg->u.attrs, arg->server);
+ encode_attrs(xdr, arg->u.attrs, arg->label,
+ arg->server);
} else {
struct iattr dummy;
*p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE4_1);
encode_nfs4_verifier(xdr, &arg->u.verifier);
dummy.ia_valid = 0;
- encode_attrs(xdr, &dummy, arg->server);
+ encode_attrs(xdr, &dummy, arg->label,
+ arg->server);
}
} else {
*p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE);
@@ -1570,20 +1597,34 @@ static void encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg
encode_op_hdr(xdr, OP_READDIR, decode_readdir_maxsz, hdr);
encode_uint64(xdr, readdir->cookie);
encode_nfs4_verifier(xdr, &readdir->verifier);
- p = reserve_space(xdr, 20);
+ p = reserve_space(xdr, encode_readdir_space);
*p++ = cpu_to_be32(dircount);
*p++ = cpu_to_be32(readdir->count);
- *p++ = cpu_to_be32(2);
-
+ *p++ = cpu_to_be32(encode_readdir_bitmask_sz);
*p++ = cpu_to_be32(attrs[0] & readdir->bitmask[0]);
- *p = cpu_to_be32(attrs[1] & readdir->bitmask[1]);
+ *p = cpu_to_be32(attrs[1] & readdir->bitmask[1]);
+ if (encode_readdir_bitmask_sz > 2) {
+ p++, *p++ = cpu_to_be32(readdir->bitmask[2]);
+ }
memcpy(verf, readdir->verifier.data, sizeof(verf));
- dprintk("%s: cookie = %Lu, verifier = %08x:%08x, bitmap = %08x:%08x\n",
+
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+ dprintk("%s: cookie = %llu, verifier = %08x:%08x, bitmap = %08x:%08x:%08x\n",
+ __func__,
+ (unsigned long long)readdir->cookie,
+ verf[0], verf[1],
+ attrs[0] & readdir->bitmask[0],
+ attrs[1] & readdir->bitmask[1],
+ readdir->bitmask[2]);
+#else
+ dprintk("%s: cookie = %llu, verifier = %08x:%08x, bitmap = %08x:%08x\n",
__func__,
(unsigned long long)readdir->cookie,
verf[0], verf[1],
attrs[0] & readdir->bitmask[0],
attrs[1] & readdir->bitmask[1]);
+#endif
+
}
static void encode_readlink(struct xdr_stream *xdr, const struct nfs4_readlink *readlink, struct rpc_rqst *req, struct compound_hdr *hdr)
@@ -1642,7 +1683,7 @@ static void encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs
{
encode_op_hdr(xdr, OP_SETATTR, decode_setattr_maxsz, hdr);
encode_nfs4_stateid(xdr, &arg->stateid);
- encode_attrs(xdr, arg->iap, server);
+ encode_attrs(xdr, arg->iap, arg->label, server);
}
static void encode_setclientid(struct xdr_stream *xdr, const struct nfs4_setclientid *setclientid, struct compound_hdr *hdr)
@@ -4060,6 +4101,67 @@ static int decode_attr_time_delta(struct xdr_stream *xdr, uint32_t *bitmap,
return status;
}
+static int decode_attr_security_label(struct xdr_stream *xdr, uint32_t *bitmap,
+ struct nfs4_label *label)
+{
+ uint32_t pi = 0;
+ uint32_t lfs = 0;
+ __u32 len;
+ __be32 *p;
+ int status = 0;
+
+ if (unlikely(bitmap[2] & (FATTR4_WORD2_SECURITY_LABEL - 1U)))
+ return -EIO;
+ if (likely(bitmap[2] & FATTR4_WORD2_SECURITY_LABEL)) {
+ p = xdr_inline_decode(xdr, 4);
+ if (unlikely(!p))
+ goto out_overflow;
+ lfs = be32_to_cpup(p++);
+ p = xdr_inline_decode(xdr, 4);
+ if (unlikely(!p))
+ goto out_overflow;
+ pi = be32_to_cpup(p++);
+ p = xdr_inline_decode(xdr, 4);
+ if (unlikely(!p))
+ goto out_overflow;
+ len = be32_to_cpup(p++);
+ p = xdr_inline_decode(xdr, len);
+ if (unlikely(!p))
+ goto out_overflow;
+ if (len < XDR_MAX_NETOBJ) {
+ if (label) {
+ nfs4_label_init(label);
+ if (label->len < len) {
+ printk(KERN_ERR
+ "%s(): label->len %d < len %d\n",
+ __func__, label->len, len);
+ } else {
+ memcpy(label->label, p, len);
+ label->len = len;
+ label->pi = pi;
+ label->lfs = lfs;
+ status = NFS_ATTR_FATTR_V4_SECURITY_LABEL;
+ }
+ } else {
+ printk("%s(): NULL label.\n", __func__);
+ dump_stack();
+ goto out_overflow;
+ }
+ bitmap[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
+ } else
+ printk(KERN_WARNING "%s: label too long (%u)!\n",
+ __func__, len);
+ }
+ if (label && label->label)
+ dprintk("%s: label=%s, len=%d, PI=%d, LFS=%d\n", __func__,
+ (char *)label->label, label->len, label->pi, label->lfs);
+ return status;
+
+out_overflow:
+ print_overflow_msg(__func__, xdr);
+ return -EIO;
+}
+
static int decode_attr_time_modify(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
{
int status = 0;
@@ -4402,7 +4504,7 @@ out_overflow:
static int decode_getfattr_attrs(struct xdr_stream *xdr, uint32_t *bitmap,
struct nfs_fattr *fattr, struct nfs_fh *fh,
- struct nfs4_fs_locations *fs_loc,
+ struct nfs4_fs_locations *fs_loc, struct nfs4_label *label,
const struct nfs_server *server)
{
int status;
@@ -4510,6 +4612,11 @@ static int decode_getfattr_attrs(struct xdr_stream *xdr, uint32_t *bitmap,
if (status < 0)
goto xdr_error;
+ status = decode_attr_security_label(xdr, bitmap, label);
+ if (status < 0)
+ goto xdr_error;
+ fattr->valid |= status;
+
xdr_error:
dprintk("%s: xdr returned %d\n", __func__, -status);
return status;
@@ -4517,7 +4624,7 @@ xdr_error:
static int decode_getfattr_generic(struct xdr_stream *xdr, struct nfs_fattr *fattr,
struct nfs_fh *fh, struct nfs4_fs_locations *fs_loc,
- const struct nfs_server *server)
+ struct nfs4_label *label, const struct nfs_server *server)
{
unsigned int savep;
uint32_t attrlen,
@@ -4536,7 +4643,8 @@ static int decode_getfattr_generic(struct xdr_stream *xdr, struct nfs_fattr *fat
if (status < 0)
goto xdr_error;
- status = decode_getfattr_attrs(xdr, bitmap, fattr, fh, fs_loc, server);
+ status = decode_getfattr_attrs(xdr, bitmap, fattr, fh, fs_loc,
+ label, server);
if (status < 0)
goto xdr_error;
@@ -4547,9 +4655,9 @@ xdr_error:
}
static int decode_getfattr(struct xdr_stream *xdr, struct nfs_fattr *fattr,
- const struct nfs_server *server)
+ struct nfs4_label *label, const struct nfs_server *server)
{
- return decode_getfattr_generic(xdr, fattr, NULL, NULL, server);
+ return decode_getfattr_generic(xdr, fattr, NULL, NULL, label, server);
}
/*
@@ -5883,7 +5991,7 @@ static int nfs4_xdr_dec_open_downgrade(struct rpc_rqst *rqstp,
status = decode_open_downgrade(xdr, res);
if (status != 0)
goto out;
- decode_getfattr(xdr, res->fattr, res->server);
+ decode_getfattr(xdr, res->fattr, res->label, res->server);
out:
return status;
}
@@ -5909,7 +6017,7 @@ static int nfs4_xdr_dec_access(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
status = decode_access(xdr, &res->supported, &res->access);
if (status != 0)
goto out;
- decode_getfattr(xdr, res->fattr, res->server);
+ decode_getfattr(xdr, res->fattr, res->label, res->server);
out:
return status;
}
@@ -5938,7 +6046,7 @@ static int nfs4_xdr_dec_lookup(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
status = decode_getfh(xdr, res->fh);
if (status)
goto out;
- status = decode_getfattr(xdr, res->fattr, res->server);
+ status = decode_getfattr(xdr, res->fattr, res->label, res->server);
out:
return status;
}
@@ -5964,7 +6072,8 @@ static int nfs4_xdr_dec_lookup_root(struct rpc_rqst *rqstp,
goto out;
status = decode_getfh(xdr, res->fh);
if (status == 0)
- status = decode_getfattr(xdr, res->fattr, res->server);
+ status = decode_getfattr(xdr, res->fattr,
+ res->label, res->server);
out:
return status;
}
@@ -6055,7 +6164,7 @@ static int nfs4_xdr_dec_link(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
status = decode_restorefh(xdr);
if (status)
goto out;
- decode_getfattr(xdr, res->fattr, res->server);
+ decode_getfattr(xdr, res->fattr, res->label, res->server);
out:
return status;
}
@@ -6084,7 +6193,7 @@ static int nfs4_xdr_dec_create(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
status = decode_getfh(xdr, res->fh);
if (status)
goto out;
- decode_getfattr(xdr, res->fattr, res->server);
+ decode_getfattr(xdr, res->fattr, res->label, res->server);
out:
return status;
}
@@ -6116,7 +6225,7 @@ static int nfs4_xdr_dec_getattr(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
status = decode_putfh(xdr);
if (status)
goto out;
- status = decode_getfattr(xdr, res->fattr, res->server);
+ status = decode_getfattr(xdr, res->fattr, res->label, res->server);
out:
return status;
}
@@ -6218,7 +6327,7 @@ static int nfs4_xdr_dec_close(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
* an ESTALE error. Shouldn't be a problem,
* though, since fattr->valid will remain unset.
*/
- decode_getfattr(xdr, res->fattr, res->server);
+ decode_getfattr(xdr, res->fattr, res->label, res->server);
out:
return status;
}
@@ -6249,7 +6358,7 @@ static int nfs4_xdr_dec_open(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
goto out;
if (res->access_request)
decode_access(xdr, &res->access_supported, &res->access_result);
- decode_getfattr(xdr, res->f_attr, res->server);
+ decode_getfattr(xdr, res->f_attr, res->f_label, res->server);
out:
return status;
}
@@ -6299,7 +6408,7 @@ static int nfs4_xdr_dec_open_noattr(struct rpc_rqst *rqstp,
goto out;
if (res->access_request)
decode_access(xdr, &res->access_supported, &res->access_result);
- decode_getfattr(xdr, res->f_attr, res->server);
+ decode_getfattr(xdr, res->f_attr, NULL, res->server);
out:
return status;
}
@@ -6326,7 +6435,7 @@ static int nfs4_xdr_dec_setattr(struct rpc_rqst *rqstp,
status = decode_setattr(xdr);
if (status)
goto out;
- decode_getfattr(xdr, res->fattr, res->server);
+ decode_getfattr(xdr, res->fattr, res->label, res->server);
out:
return status;
}
@@ -6506,7 +6615,7 @@ static int nfs4_xdr_dec_write(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
if (status)
goto out;
if (res->fattr)
- decode_getfattr(xdr, res->fattr, res->server);
+ decode_getfattr(xdr, res->fattr, NULL, res->server);
if (!status)
status = res->count;
out:
@@ -6687,7 +6796,7 @@ static int nfs4_xdr_dec_delegreturn(struct rpc_rqst *rqstp,
status = decode_putfh(xdr);
if (status != 0)
goto out;
- status = decode_getfattr(xdr, res->fattr, res->server);
+ status = decode_getfattr(xdr, res->fattr, res->label, res->server);
if (status != 0)
goto out;
status = decode_delegreturn(xdr);
@@ -6720,7 +6829,7 @@ static int nfs4_xdr_dec_fs_locations(struct rpc_rqst *req,
xdr_enter_page(xdr, PAGE_SIZE);
status = decode_getfattr_generic(xdr, &res->fs_locations->fattr,
NULL, res->fs_locations,
- res->fs_locations->server);
+ NULL, res->fs_locations->server);
out:
return status;
}
@@ -7001,7 +7110,7 @@ static int nfs4_xdr_dec_layoutcommit(struct rpc_rqst *rqstp,
status = decode_layoutcommit(xdr, rqstp, res);
if (status)
goto out;
- decode_getfattr(xdr, res->fattr, res->server);
+ decode_getfattr(xdr, res->fattr, NULL, res->server);
out:
return status;
}
@@ -7133,7 +7242,7 @@ int nfs4_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry,
goto out_overflow;
if (decode_getfattr_attrs(xdr, bitmap, entry->fattr, entry->fh,
- NULL, entry->server) < 0)
+ NULL, entry->label, entry->server) < 0)
goto out_overflow;
if (entry->fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID)
entry->ino = entry->fattr->mounted_on_fileid;
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index c98b434..4e78f93 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -2419,8 +2419,21 @@ static int nfs_bdi_register(struct nfs_server *server)
int nfs_set_sb_security(struct super_block *s, struct dentry *mntroot,
struct nfs_mount_info *mount_info)
{
- return security_sb_set_mnt_opts(s, &mount_info->parsed->lsm_opts,
- 0, NULL);
+ int error;
+ unsigned long kflags = 0, kflags_out = 0;
+ if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL)
+ kflags |= SECURITY_LSM_NATIVE_LABELS;
+
+ error = security_sb_set_mnt_opts(s, &mount_info->parsed->lsm_opts,
+ kflags, &kflags_out);
+ if (error)
+ goto err;
+
+ if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL &&
+ !(kflags_out & SECURITY_LSM_NATIVE_LABELS))
+ NFS_SB(s)->caps &= ~NFS_CAP_SECURITY_LABEL;
+err:
+ return error;
}
EXPORT_SYMBOL_GPL(nfs_set_sb_security);
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 41b0b6d..ff4f72a 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -199,6 +199,7 @@ struct nfs_inode {
#define NFS_INO_INVALID_ACL 0x0010 /* cached acls are invalid */
#define NFS_INO_REVAL_PAGECACHE 0x0020 /* must revalidate pagecache */
#define NFS_INO_REVAL_FORCED 0x0040 /* force revalidation ignoring a delegation */
+#define NFS_INO_INVALID_LABEL 0x0080 /* cached label is invalid */
/*
* Bit offsets in flags field
@@ -344,6 +345,8 @@ extern int __nfs_revalidate_inode(struct nfs_server *, struct inode *);
extern int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping);
extern int nfs_setattr(struct dentry *, struct iattr *);
extern void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr);
+extern void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr,
+ struct nfs4_label *label);
extern struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx);
extern void put_nfs_open_context(struct nfs_open_context *ctx);
extern struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode);
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index e6ed3c2..2a4f1d4 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -145,11 +145,18 @@ struct nfs_server {
u32 attr_bitmask[3];/* V4 bitmask representing the set
of attributes supported on this
filesystem */
+ u32 attr_bitmask_nl[3];
+ /* V4 bitmask representing the
+ set of attributes supported
+ on this filesystem excluding
+ the label support bit. */
u32 cache_consistency_bitmask[3];
/* V4 bitmask representing the subset
of change attribute, size, ctime
and mtime attributes supported by
the server */
+ u32 cache_consistency_bitmask_nl[3];
+ /* As above, excluding label. */
u32 acl_bitmask; /* V4 bitmask representing the ACEs
that are supported on this
filesystem */
diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index dda436f..af947f8 100644
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -2876,7 +2876,10 @@ static void selinux_inode_post_setxattr(struct dentry *dentry, const char *name,
return;
}
+ isec->sclass = inode_mode_to_security_class(inode->i_mode);
isec->sid = newsid;
+ isec->initialized = 1;
+
return;
}
@@ -2964,6 +2967,7 @@ static int selinux_inode_setsecurity(struct inode *inode, const char *name,
if (rc)
return rc;
+ isec->sclass = inode_mode_to_security_class(inode->i_mode);
isec->sid = newsid;
isec->initialized = 1;
return 0;
--
1.7.11.7
--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply related [flat|nested] 58+ messages in thread
* [PATCH 10/15] NFS: Client implementation of Labeled-NFS
@ 2013-02-08 12:39 ` Steve Dickson
0 siblings, 0 replies; 58+ messages in thread
From: Steve Dickson @ 2013-02-08 12:39 UTC (permalink / raw)
To: Trond Myklebust, J. Bruce Fields, David P. Quigley
Cc: Linux NFS list, Linux FS devel list, Linux Security List, SELinux List
From: David Quigley <dpquigl@davequigley.com>
This patch implements the client transport and handling support for labeled
NFS. The patch adds two functions to encode and decode the security label
recommended attribute which makes use of the LSM hooks added earlier. It also
adds code to grab the label from the file attribute structures and encode the
label to be sent back to the server.
Signed-off-by: Matthew N. Dodd <Matthew.Dodd@sparta.com>
Signed-off-by: Miguel Rodel Felipe <Rodel_FM@dsi.a-star.edu.sg>
Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene@dsi.a-star.edu.sg>
Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG@dsi.a-star.edu.sg>
---
fs/nfs/inode.c | 55 ++++++++-
fs/nfs/nfs4proc.c | 298 ++++++++++++++++++++++++++++++++++++++++++++--
fs/nfs/nfs4xdr.c | 179 ++++++++++++++++++++++------
fs/nfs/super.c | 17 ++-
include/linux/nfs_fs.h | 3 +
include/linux/nfs_fs_sb.h | 7 ++
security/selinux/hooks.c | 4 +
7 files changed, 507 insertions(+), 56 deletions(-)
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 0cb67cf..0d412c4 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -162,11 +162,19 @@ static void nfs_zap_caches_locked(struct inode *inode)
memset(NFS_I(inode)->cookieverf, 0, sizeof(NFS_I(inode)->cookieverf));
if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) {
- nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
nfs_fscache_invalidate(inode);
- } else {
- nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
- }
+ nfsi->cache_validity |= NFS_INO_INVALID_ATTR
+ | NFS_INO_INVALID_LABEL
+ | NFS_INO_INVALID_DATA
+ | NFS_INO_INVALID_ACCESS
+ | NFS_INO_INVALID_ACL
+ | NFS_INO_REVAL_PAGECACHE;
+ } else
+ nfsi->cache_validity |= NFS_INO_INVALID_ATTR
+ | NFS_INO_INVALID_LABEL
+ | NFS_INO_INVALID_ACCESS
+ | NFS_INO_INVALID_ACL
+ | NFS_INO_REVAL_PAGECACHE;
}
void nfs_zap_caches(struct inode *inode)
@@ -256,6 +264,24 @@ nfs_init_locked(struct inode *inode, void *opaque)
}
#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr,
+ struct nfs4_label *label)
+{
+ int error;
+
+ if ((fattr->valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL) &&
+ label && inode->i_security) {
+ error = security_inode_notifysecctx(inode, label->label,
+ label->len);
+ if (error)
+ printk(KERN_ERR "%s() %s %d "
+ "security_inode_notifysecctx() %d\n",
+ __func__,
+ (char *)label->label,
+ label->len, error);
+ }
+}
+
struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags)
{
struct nfs4_label *label = NULL;
@@ -286,7 +312,15 @@ void nfs4_label_init(struct nfs4_label *label)
return;
}
EXPORT_SYMBOL_GPL(nfs4_label_init);
+EXPORT_SYMBOL_GPL(nfs4_label_free);
+
+#else
+void inline nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr,
+ struct nfs4_label *label)
+{
+}
#endif
+EXPORT_SYMBOL_GPL(nfs_setsecurity);
/*
* This is our front-end to iget that looks up inodes by file handle
@@ -415,6 +449,9 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr, st
*/
inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
}
+
+ nfs_setsecurity(inode, fattr, label);
+
nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
nfsi->attrtimeo_timestamp = now;
nfsi->access_cache = RB_ROOT;
@@ -777,6 +814,7 @@ struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_c
spin_unlock(&inode->i_lock);
return ctx;
}
+EXPORT_SYMBOL_GPL(nfs_find_open_context);
static void nfs_file_clear_open_context(struct file *filp)
{
@@ -905,7 +943,8 @@ static int nfs_attribute_cache_expired(struct inode *inode)
*/
int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
{
- if (!(NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATTR)
+ if (!(NFS_I(inode)->cache_validity &
+ (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_LABEL))
&& !nfs_attribute_cache_expired(inode))
return NFS_STALE(inode) ? -ESTALE : 0;
return __nfs_revalidate_inode(server, inode);
@@ -1504,6 +1543,9 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr, struct
| NFS_INO_INVALID_ACL
| NFS_INO_REVAL_FORCED);
+ if (label && (server->caps & NFS_CAP_SECURITY_LABEL))
+ nfs_setsecurity(inode, fattr, label);
+
if (fattr->valid & NFS_ATTR_FATTR_NLINK) {
if (inode->i_nlink != fattr->nlink) {
invalid |= NFS_INO_INVALID_ATTR;
@@ -1525,7 +1567,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr, struct
inode->i_blocks = fattr->du.nfs2.blocks;
/* Update attrtimeo value if we're out of the unstable period */
- if (invalid & NFS_INO_INVALID_ATTR) {
+ if (invalid & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_LABEL)) {
nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
nfsi->attrtimeo_timestamp = now;
@@ -1538,6 +1580,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr, struct
}
}
invalid &= ~NFS_INO_INVALID_ATTR;
+ invalid &= ~NFS_INO_INVALID_LABEL;
/* Don't invalidate the data if we were to blame */
if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
|| S_ISLNK(inode->i_mode)))
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 5c9233d1..280bb22 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -87,6 +87,39 @@ static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
static int nfs41_test_stateid(struct nfs_server *, nfs4_stateid *);
static int nfs41_free_stateid(struct nfs_server *, nfs4_stateid *);
#endif
+
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+static inline struct nfs4_label *
+nfs4_label_init_security(struct inode *dir, struct dentry *dentry,
+ struct iattr *sattr, struct nfs4_label *l)
+{
+ int err;
+
+ if (nfs_server_capable(dir, NFS_CAP_SECURITY_LABEL)) {
+ err = security_dentry_init_security(dentry, sattr->ia_mode,
+ &dentry->d_name, (void **)&l->label, &l->len);
+ if (err == 0)
+ return l;
+ }
+ return NULL;
+}
+static inline void
+nfs4_label_release_security(struct nfs4_label *label)
+{
+ if (label)
+ security_release_secctx(label->label, label->len);
+}
+#else
+static inline struct nfs4_label *
+nfs4_label_init_security(struct inode *dir, struct dentry *dentry,
+ struct iattr *sattr, struct nfs4_label *l)
+{ return NULL; }
+
+static inline void
+nfs4_label_release_security(struct nfs4_label *label)
+{ return; }
+#endif
+
/* Prevent leaks of NFSv4 errors into userland */
static int nfs4_map_errors(int err)
{
@@ -131,7 +164,8 @@ const u32 nfs4_fattr_bitmap[3] = {
| FATTR4_WORD1_SPACE_USED
| FATTR4_WORD1_TIME_ACCESS
| FATTR4_WORD1_TIME_METADATA
- | FATTR4_WORD1_TIME_MODIFY
+ | FATTR4_WORD1_TIME_MODIFY,
+ FATTR4_WORD2_SECURITY_LABEL
};
static const u32 nfs4_pnfs_open_bitmap[3] = {
@@ -1939,6 +1973,7 @@ static int _nfs4_do_open(struct inode *dir,
if (status == 0) {
nfs_setattr_update_inode(state->inode, sattr);
nfs_post_op_update_inode(state->inode, opendata->o_res.f_attr, olabel);
+ nfs_setsecurity(state->inode, opendata->o_res.f_attr, olabel);
}
}
@@ -2052,6 +2087,9 @@ static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
unsigned long timestamp = jiffies;
int status;
+ if (ilabel == NULL || olabel == NULL)
+ arg.bitmask = server->attr_bitmask_nl;
+
nfs_fattr_init(fattr);
if (state != NULL) {
@@ -2279,7 +2317,7 @@ int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait)
if (calldata->arg.seqid == NULL)
goto out_free_calldata;
calldata->arg.fmode = 0;
- calldata->arg.bitmask = server->cache_consistency_bitmask;
+ calldata->arg.bitmask = server->cache_consistency_bitmask_nl;
calldata->res.fattr = &calldata->fattr;
calldata->res.seqid = calldata->arg.seqid;
calldata->res.server = server;
@@ -2309,11 +2347,16 @@ static struct inode *
nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx, int open_flags, struct iattr *attr)
{
struct nfs4_state *state;
- struct nfs4_label *label = NULL;
+ struct nfs4_label l, *label = NULL;
+
+ label = nfs4_label_init_security(dir, ctx->dentry, attr, &l);
/* Protect against concurrent sillydeletes */
state = nfs4_do_open(dir, ctx->dentry, ctx->mode, open_flags, attr, label,
ctx->cred, &ctx->mdsthreshold);
+
+ nfs4_label_release_security(label);
+
if (IS_ERR(state))
return ERR_CAST(state);
ctx->state = state;
@@ -2373,10 +2416,27 @@ static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *f
server->caps |= NFS_CAP_CTIME;
if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY)
server->caps |= NFS_CAP_MTIME;
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+ if (res.attr_bitmask[2] & FATTR4_WORD2_SECURITY_LABEL) {
+ server->caps |= NFS_CAP_SECURITY_LABEL;
+ } else
+#endif
+ server->attr_bitmask[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
+
+ if (server->caps & NFS_CAP_SECURITY_LABEL) {
+ memcpy(server->attr_bitmask_nl, res.attr_bitmask,
+ sizeof(server->attr_bitmask));
+ server->attr_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
+ }
memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask));
server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE;
- server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY;
+ server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA |
+ FATTR4_WORD1_TIME_MODIFY;
+ server->cache_consistency_bitmask[2] &= FATTR4_WORD2_SECURITY_LABEL;
+ memcpy(server->cache_consistency_bitmask_nl, server->cache_consistency_bitmask,
+ sizeof(server->cache_consistency_bitmask_nl));
+ server->cache_consistency_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
server->acl_bitmask = res.acl_bitmask;
server->fh_expire_type = res.fh_expire_type;
}
@@ -2399,8 +2459,9 @@ int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
struct nfs_fsinfo *info)
{
+ u32 bitmask[3];
struct nfs4_lookup_root_arg args = {
- .bitmask = nfs4_fattr_bitmap,
+ .bitmask = bitmask,
};
struct nfs4_lookup_res res = {
.server = server,
@@ -2413,6 +2474,13 @@ static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
.rpc_resp = &res,
};
+ bitmask[0] = nfs4_fattr_bitmap[0];
+ bitmask[1] = nfs4_fattr_bitmap[1];
+ /*
+ * Process the label in the upcoming getfattr
+ */
+ bitmask[2] = nfs4_fattr_bitmap[2] & ~FATTR4_WORD2_SECURITY_LABEL;
+
nfs_fattr_init(info->fattr);
return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
}
@@ -2599,7 +2667,10 @@ static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
.rpc_argp = &args,
.rpc_resp = &res,
};
-
+
+ if (!label)
+ args.bitmask = server->attr_bitmask_nl;
+
nfs_fattr_init(fattr);
return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
}
@@ -2694,6 +2765,7 @@ static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir,
struct nfs4_lookup_res res = {
.server = server,
.fattr = fattr,
+ .label = label,
.fh = fhandle,
};
struct rpc_message msg = {
@@ -2702,6 +2774,9 @@ static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir,
.rpc_resp = &res,
};
+ if (label == NULL)
+ args.bitmask = server->attr_bitmask_nl;
+
nfs_fattr_init(fattr);
dprintk("NFS call lookup %s\n", name->name);
@@ -2808,7 +2883,7 @@ static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry
.rpc_cred = entry->cred,
};
int mode = entry->mask;
- int status;
+ int status = 0;
/*
* Determine which access bits we want to ask for...
@@ -2923,7 +2998,7 @@ static int
nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
int flags)
{
- struct nfs4_label *ilabel = NULL;
+ struct nfs4_label l, *ilabel = NULL;
struct nfs_open_context *ctx;
struct nfs4_state *state;
int status = 0;
@@ -2932,6 +3007,8 @@ nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
if (IS_ERR(ctx))
return PTR_ERR(ctx);
+ ilabel = nfs4_label_init_security(dir, dentry, sattr, &l);
+
sattr->ia_mode &= ~current_umask();
state = nfs4_do_open(dir, dentry, ctx->mode,
flags, sattr, ilabel, ctx->cred,
@@ -2945,6 +3022,7 @@ nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
ctx->state = state;
out:
+ nfs4_label_release_security(ilabel);
put_nfs_open_context(ctx);
return status;
}
@@ -2994,6 +3072,8 @@ static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
res->server = server;
msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE];
nfs41_init_sequence(&args->seq_args, &res->seq_res, 1);
+
+ nfs_fattr_init(res->dir_attr);
}
static void nfs4_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
@@ -3263,14 +3343,19 @@ static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
struct page *page, unsigned int len, struct iattr *sattr)
{
struct nfs4_exception exception = { };
- struct nfs4_label *label = NULL;
+ struct nfs4_label l, *label = NULL;
int err;
+
+ label = nfs4_label_init_security(dir, dentry, sattr, &l);
+
do {
err = nfs4_handle_exception(NFS_SERVER(dir),
_nfs4_proc_symlink(dir, dentry, page,
len, sattr, label),
&exception);
} while (exception.retry);
+
+ nfs4_label_release_security(label);
return err;
}
@@ -3296,15 +3381,19 @@ static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
struct iattr *sattr)
{
struct nfs4_exception exception = { };
- struct nfs4_label *label = NULL;
+ struct nfs4_label l, *label = NULL;
int err;
+ label = nfs4_label_init_security(dir, dentry, sattr, &l);
+
sattr->ia_mode &= ~current_umask();
do {
err = nfs4_handle_exception(NFS_SERVER(dir),
_nfs4_proc_mkdir(dir, dentry, sattr, label),
&exception);
} while (exception.retry);
+ nfs4_label_release_security(label);
+
return err;
}
@@ -3320,7 +3409,9 @@ static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
.bitmask = NFS_SERVER(dentry->d_inode)->attr_bitmask,
.plus = plus,
};
- struct nfs4_readdir_res res;
+ struct nfs4_readdir_res res = {
+ .pgbase = 0,
+ };
struct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR],
.rpc_argp = &args,
@@ -3400,15 +3491,20 @@ static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
struct iattr *sattr, dev_t rdev)
{
struct nfs4_exception exception = { };
- struct nfs4_label *label = NULL;
+ struct nfs4_label l, *label = NULL;
int err;
+ label = nfs4_label_init_security(dir, dentry, sattr, &l);
+
sattr->ia_mode &= ~current_umask();
do {
err = nfs4_handle_exception(NFS_SERVER(dir),
_nfs4_proc_mknod(dir, dentry, sattr, label, rdev),
&exception);
} while (exception.retry);
+
+ nfs4_label_release_security(label);
+
return err;
}
@@ -3624,7 +3720,11 @@ static void nfs4_proc_write_setup(struct nfs_write_data *data, struct rpc_messag
data->args.bitmask = NULL;
data->res.fattr = NULL;
} else
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+ data->args.bitmask = server->cache_consistency_bitmask_nl;
+#else
data->args.bitmask = server->cache_consistency_bitmask;
+#endif
if (!data->write_done_cb)
data->write_done_cb = nfs4_write_done_cb;
@@ -4049,6 +4149,178 @@ static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen
return err;
}
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+static int _nfs4_get_security_label(struct inode *inode, void *buf,
+ size_t buflen)
+{
+ struct nfs_server *server = NFS_SERVER(inode);
+ struct nfs_fattr fattr;
+ struct nfs4_label label = {0, 0, buflen, buf};
+ u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL };
+ struct nfs4_getattr_arg args = {
+ .fh = NFS_FH(inode),
+ .bitmask = bitmask,
+ };
+ struct nfs4_getattr_res res = {
+ .fattr = &fattr,
+ .label = &label,
+ .server = server,
+ };
+ struct rpc_message msg = {
+ .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
+ .rpc_argp = &args,
+ .rpc_resp = &res,
+ };
+ int ret;
+
+ nfs_fattr_init(&fattr);
+
+ ret = rpc_call_sync(server->client, &msg, 0);
+ if (ret)
+ return ret;
+ if (!(fattr.valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL))
+ return -ENOENT;
+ if (buflen < label.len)
+ return -ERANGE;
+ return 0;
+}
+
+static int nfs4_get_security_label(struct inode *inode, void *buf,
+ size_t buflen)
+{
+ struct nfs4_exception exception = { };
+ int err;
+
+ if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
+ return -EOPNOTSUPP;
+
+ do {
+ err = nfs4_handle_exception(NFS_SERVER(inode),
+ _nfs4_get_security_label(inode, buf, buflen),
+ &exception);
+ } while (exception.retry);
+ return err;
+}
+
+static int _nfs4_do_set_security_label(struct inode *inode,
+ struct nfs4_label *ilabel,
+ struct nfs_fattr *fattr,
+ struct nfs4_label *olabel,
+ struct nfs4_state *state)
+{
+
+ struct iattr sattr = {0};
+ struct nfs_server *server = NFS_SERVER(inode);
+ const u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL };
+ struct nfs_setattrargs args = {
+ .fh = NFS_FH(inode),
+ .iap = &sattr,
+ .server = server,
+ .bitmask = bitmask,
+ .label = ilabel,
+ };
+ struct nfs_setattrres res = {
+ .fattr = fattr,
+ .label = olabel,
+ .server = server,
+ };
+ struct rpc_message msg = {
+ .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
+ .rpc_argp = &args,
+ .rpc_resp = &res,
+ };
+ unsigned long timestamp = jiffies;
+ int status;
+
+ if (state != NULL) {
+ struct nfs_lockowner lockowner = {
+ .l_owner = current->files,
+ .l_pid = current->tgid,
+ };
+
+ msg.rpc_cred = state->owner->so_cred;
+ nfs4_select_rw_stateid(&args.stateid, state, FMODE_WRITE,
+ &lockowner);
+ } else if (nfs4_copy_delegation_stateid(&args.stateid, inode,
+ FMODE_WRITE)) {
+ /* Use that stateid */
+ } else
+ nfs4_stateid_copy(&args.stateid, &zero_stateid);
+
+ status = rpc_call_sync(server->client, &msg, 0);
+ if (status == 0 && state != NULL)
+ renew_lease(server, timestamp);
+ return status;
+}
+
+static int nfs4_do_set_security_label(struct inode *inode,
+ struct nfs4_label *ilabel,
+ struct nfs_fattr *fattr,
+ struct nfs4_label *olabel,
+ struct nfs4_state *state)
+{
+ struct nfs4_exception exception = { };
+ int err;
+
+ do {
+ err = nfs4_handle_exception(NFS_SERVER(inode),
+ _nfs4_do_set_security_label(inode, ilabel,
+ fattr, olabel, state),
+ &exception);
+ } while (exception.retry);
+ return err;
+}
+
+static int
+nfs4_set_security_label(struct dentry *dentry, const void *buf, size_t buflen)
+{
+ struct nfs4_label ilabel, *olabel = NULL;
+ struct nfs_fattr fattr;
+ struct rpc_cred *cred;
+ struct nfs_open_context *ctx;
+ struct nfs4_state *state = NULL;
+ struct inode *inode = dentry->d_inode;
+ int status;
+
+ if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
+ return -EOPNOTSUPP;
+
+ nfs_fattr_init(&fattr);
+
+ ilabel.pi = 0;
+ ilabel.lfs = 0;
+ ilabel.label = (char *)buf;
+ ilabel.len = buflen;
+
+ cred = rpc_lookup_cred();
+ if (IS_ERR(cred))
+ return PTR_ERR(cred);
+
+ olabel = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
+ if (IS_ERR(olabel)) {
+ status = -PTR_ERR(olabel);
+ goto out;
+ }
+
+ /* Search for an existing open(O_WRITE) file */
+ ctx = nfs_find_open_context(inode, cred, FMODE_WRITE);
+ if (ctx != NULL)
+ state = ctx->state;
+
+ status = nfs4_do_set_security_label(inode, &ilabel, &fattr, olabel,
+ state);
+ if (status == 0)
+ nfs_setsecurity(inode, &fattr, olabel);
+ if (ctx != NULL)
+ put_nfs_open_context(ctx);
+ nfs4_label_free(olabel);
+out:
+ put_rpccred(cred);
+ return status;
+}
+#endif /* CONFIG_NFS_V4_SECURITY_LABEL */
+
+
static int
nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server, struct nfs4_state *state)
{
@@ -4337,7 +4609,7 @@ static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, co
nfs41_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
data->args.fhandle = &data->fh;
data->args.stateid = &data->stateid;
- data->args.bitmask = server->cache_consistency_bitmask;
+ data->args.bitmask = server->cache_consistency_bitmask_nl;
nfs_copy_fh(&data->fh, NFS_FH(inode));
nfs4_stateid_copy(&data->stateid, stateid);
data->res.fattr = &data->fattr;
diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index a9353d1..3725433 100644
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -102,12 +102,23 @@ static int nfs4_stat_to_errno(int);
#define nfs4_path_maxsz (1 + ((3 + NFS4_MAXPATHLEN) >> 2))
#define nfs4_owner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
#define nfs4_group_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+/* PI(4 bytes) + LFS(4 bytes) + 1(for null terminator?) + MAXLABELLEN */
+#define nfs4_label_maxsz (4 + 4 + 1 + XDR_QUADLEN(NFS4_MAXLABELLEN))
+#define encode_readdir_space 24
+#define encode_readdir_bitmask_sz 3
+#else
+#define nfs4_label_maxsz 0
+#define encode_readdir_space 20
+#define encode_readdir_bitmask_sz 2
+#endif
/* We support only one layout type per file system */
#define decode_mdsthreshold_maxsz (1 + 1 + nfs4_fattr_bitmap_maxsz + 1 + 8)
/* This is based on getfattr, which uses the most attributes: */
#define nfs4_fattr_value_maxsz (1 + (1 + 2 + 2 + 4 + 2 + 1 + 1 + 2 + 2 + \
3 + 3 + 3 + nfs4_owner_maxsz + \
- nfs4_group_maxsz + decode_mdsthreshold_maxsz))
+ nfs4_group_maxsz + nfs4_label_maxsz + \
+ decode_mdsthreshold_maxsz))
#define nfs4_fattr_maxsz (nfs4_fattr_bitmap_maxsz + \
nfs4_fattr_value_maxsz)
#define decode_getattr_maxsz (op_decode_hdr_maxsz + nfs4_fattr_maxsz)
@@ -115,6 +126,7 @@ static int nfs4_stat_to_errno(int);
1 + 2 + 1 + \
nfs4_owner_maxsz + \
nfs4_group_maxsz + \
+ nfs4_label_maxsz + \
4 + 4)
#define encode_savefh_maxsz (op_encode_hdr_maxsz)
#define decode_savefh_maxsz (op_decode_hdr_maxsz)
@@ -192,9 +204,11 @@ static int nfs4_stat_to_errno(int);
encode_stateid_maxsz + 3)
#define decode_read_maxsz (op_decode_hdr_maxsz + 2)
#define encode_readdir_maxsz (op_encode_hdr_maxsz + \
- 2 + encode_verifier_maxsz + 5)
+ 2 + encode_verifier_maxsz + 5 + \
+ nfs4_label_maxsz)
#define decode_readdir_maxsz (op_decode_hdr_maxsz + \
- decode_verifier_maxsz)
+ decode_verifier_maxsz + \
+ nfs4_label_maxsz + nfs4_fattr_maxsz)
#define encode_readlink_maxsz (op_encode_hdr_maxsz)
#define decode_readlink_maxsz (op_decode_hdr_maxsz + 1)
#define encode_write_maxsz (op_encode_hdr_maxsz + \
@@ -972,7 +986,9 @@ static void encode_nfs4_verifier(struct xdr_stream *xdr, const nfs4_verifier *ve
encode_opaque_fixed(xdr, verf->data, NFS4_VERIFIER_SIZE);
}
-static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const struct nfs_server *server)
+static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap,
+ const struct nfs4_label *label,
+ const struct nfs_server *server)
{
char owner_name[IDMAP_NAMESZ];
char owner_group[IDMAP_NAMESZ];
@@ -1022,6 +1038,8 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const
}
len += 4 + (XDR_QUADLEN(owner_grouplen) << 2);
}
+ if (label)
+ len += 4 + 4 + 4 + (XDR_QUADLEN(label->len) << 2);
if (iap->ia_valid & ATTR_ATIME_SET)
len += 16;
else if (iap->ia_valid & ATTR_ATIME)
@@ -1078,6 +1096,13 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const
bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET;
*p++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME);
}
+ if (label) {
+ bmval2 |= FATTR4_WORD2_SECURITY_LABEL;
+ *p++ = cpu_to_be32(label->lfs);
+ *p++ = cpu_to_be32(label->pi);
+ *p++ = cpu_to_be32(label->len);
+ p = xdr_encode_opaque_fixed(p, label->label, label->len);
+ }
/*
* Now we backfill the bitmap and the attribute buffer length.
@@ -1144,7 +1169,7 @@ static void encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg *
}
encode_string(xdr, create->name->len, create->name->name);
- encode_attrs(xdr, create->attrs, create->server);
+ encode_attrs(xdr, create->attrs, create->label, create->server);
}
static void encode_getattr_one(struct xdr_stream *xdr, uint32_t bitmap, struct compound_hdr *hdr)
@@ -1377,21 +1402,23 @@ static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_op
switch(arg->open_flags & O_EXCL) {
case 0:
*p = cpu_to_be32(NFS4_CREATE_UNCHECKED);
- encode_attrs(xdr, arg->u.attrs, arg->server);
+ encode_attrs(xdr, arg->u.attrs, arg->label, arg->server);
break;
default:
clp = arg->server->nfs_client;
if (clp->cl_mvops->minor_version > 0) {
if (nfs4_has_persistent_session(clp)) {
*p = cpu_to_be32(NFS4_CREATE_GUARDED);
- encode_attrs(xdr, arg->u.attrs, arg->server);
+ encode_attrs(xdr, arg->u.attrs, arg->label,
+ arg->server);
} else {
struct iattr dummy;
*p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE4_1);
encode_nfs4_verifier(xdr, &arg->u.verifier);
dummy.ia_valid = 0;
- encode_attrs(xdr, &dummy, arg->server);
+ encode_attrs(xdr, &dummy, arg->label,
+ arg->server);
}
} else {
*p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE);
@@ -1570,20 +1597,34 @@ static void encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg
encode_op_hdr(xdr, OP_READDIR, decode_readdir_maxsz, hdr);
encode_uint64(xdr, readdir->cookie);
encode_nfs4_verifier(xdr, &readdir->verifier);
- p = reserve_space(xdr, 20);
+ p = reserve_space(xdr, encode_readdir_space);
*p++ = cpu_to_be32(dircount);
*p++ = cpu_to_be32(readdir->count);
- *p++ = cpu_to_be32(2);
-
+ *p++ = cpu_to_be32(encode_readdir_bitmask_sz);
*p++ = cpu_to_be32(attrs[0] & readdir->bitmask[0]);
- *p = cpu_to_be32(attrs[1] & readdir->bitmask[1]);
+ *p = cpu_to_be32(attrs[1] & readdir->bitmask[1]);
+ if (encode_readdir_bitmask_sz > 2) {
+ p++, *p++ = cpu_to_be32(readdir->bitmask[2]);
+ }
memcpy(verf, readdir->verifier.data, sizeof(verf));
- dprintk("%s: cookie = %Lu, verifier = %08x:%08x, bitmap = %08x:%08x\n",
+
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+ dprintk("%s: cookie = %llu, verifier = %08x:%08x, bitmap = %08x:%08x:%08x\n",
+ __func__,
+ (unsigned long long)readdir->cookie,
+ verf[0], verf[1],
+ attrs[0] & readdir->bitmask[0],
+ attrs[1] & readdir->bitmask[1],
+ readdir->bitmask[2]);
+#else
+ dprintk("%s: cookie = %llu, verifier = %08x:%08x, bitmap = %08x:%08x\n",
__func__,
(unsigned long long)readdir->cookie,
verf[0], verf[1],
attrs[0] & readdir->bitmask[0],
attrs[1] & readdir->bitmask[1]);
+#endif
+
}
static void encode_readlink(struct xdr_stream *xdr, const struct nfs4_readlink *readlink, struct rpc_rqst *req, struct compound_hdr *hdr)
@@ -1642,7 +1683,7 @@ static void encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs
{
encode_op_hdr(xdr, OP_SETATTR, decode_setattr_maxsz, hdr);
encode_nfs4_stateid(xdr, &arg->stateid);
- encode_attrs(xdr, arg->iap, server);
+ encode_attrs(xdr, arg->iap, arg->label, server);
}
static void encode_setclientid(struct xdr_stream *xdr, const struct nfs4_setclientid *setclientid, struct compound_hdr *hdr)
@@ -4060,6 +4101,67 @@ static int decode_attr_time_delta(struct xdr_stream *xdr, uint32_t *bitmap,
return status;
}
+static int decode_attr_security_label(struct xdr_stream *xdr, uint32_t *bitmap,
+ struct nfs4_label *label)
+{
+ uint32_t pi = 0;
+ uint32_t lfs = 0;
+ __u32 len;
+ __be32 *p;
+ int status = 0;
+
+ if (unlikely(bitmap[2] & (FATTR4_WORD2_SECURITY_LABEL - 1U)))
+ return -EIO;
+ if (likely(bitmap[2] & FATTR4_WORD2_SECURITY_LABEL)) {
+ p = xdr_inline_decode(xdr, 4);
+ if (unlikely(!p))
+ goto out_overflow;
+ lfs = be32_to_cpup(p++);
+ p = xdr_inline_decode(xdr, 4);
+ if (unlikely(!p))
+ goto out_overflow;
+ pi = be32_to_cpup(p++);
+ p = xdr_inline_decode(xdr, 4);
+ if (unlikely(!p))
+ goto out_overflow;
+ len = be32_to_cpup(p++);
+ p = xdr_inline_decode(xdr, len);
+ if (unlikely(!p))
+ goto out_overflow;
+ if (len < XDR_MAX_NETOBJ) {
+ if (label) {
+ nfs4_label_init(label);
+ if (label->len < len) {
+ printk(KERN_ERR
+ "%s(): label->len %d < len %d\n",
+ __func__, label->len, len);
+ } else {
+ memcpy(label->label, p, len);
+ label->len = len;
+ label->pi = pi;
+ label->lfs = lfs;
+ status = NFS_ATTR_FATTR_V4_SECURITY_LABEL;
+ }
+ } else {
+ printk("%s(): NULL label.\n", __func__);
+ dump_stack();
+ goto out_overflow;
+ }
+ bitmap[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
+ } else
+ printk(KERN_WARNING "%s: label too long (%u)!\n",
+ __func__, len);
+ }
+ if (label && label->label)
+ dprintk("%s: label=%s, len=%d, PI=%d, LFS=%d\n", __func__,
+ (char *)label->label, label->len, label->pi, label->lfs);
+ return status;
+
+out_overflow:
+ print_overflow_msg(__func__, xdr);
+ return -EIO;
+}
+
static int decode_attr_time_modify(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
{
int status = 0;
@@ -4402,7 +4504,7 @@ out_overflow:
static int decode_getfattr_attrs(struct xdr_stream *xdr, uint32_t *bitmap,
struct nfs_fattr *fattr, struct nfs_fh *fh,
- struct nfs4_fs_locations *fs_loc,
+ struct nfs4_fs_locations *fs_loc, struct nfs4_label *label,
const struct nfs_server *server)
{
int status;
@@ -4510,6 +4612,11 @@ static int decode_getfattr_attrs(struct xdr_stream *xdr, uint32_t *bitmap,
if (status < 0)
goto xdr_error;
+ status = decode_attr_security_label(xdr, bitmap, label);
+ if (status < 0)
+ goto xdr_error;
+ fattr->valid |= status;
+
xdr_error:
dprintk("%s: xdr returned %d\n", __func__, -status);
return status;
@@ -4517,7 +4624,7 @@ xdr_error:
static int decode_getfattr_generic(struct xdr_stream *xdr, struct nfs_fattr *fattr,
struct nfs_fh *fh, struct nfs4_fs_locations *fs_loc,
- const struct nfs_server *server)
+ struct nfs4_label *label, const struct nfs_server *server)
{
unsigned int savep;
uint32_t attrlen,
@@ -4536,7 +4643,8 @@ static int decode_getfattr_generic(struct xdr_stream *xdr, struct nfs_fattr *fat
if (status < 0)
goto xdr_error;
- status = decode_getfattr_attrs(xdr, bitmap, fattr, fh, fs_loc, server);
+ status = decode_getfattr_attrs(xdr, bitmap, fattr, fh, fs_loc,
+ label, server);
if (status < 0)
goto xdr_error;
@@ -4547,9 +4655,9 @@ xdr_error:
}
static int decode_getfattr(struct xdr_stream *xdr, struct nfs_fattr *fattr,
- const struct nfs_server *server)
+ struct nfs4_label *label, const struct nfs_server *server)
{
- return decode_getfattr_generic(xdr, fattr, NULL, NULL, server);
+ return decode_getfattr_generic(xdr, fattr, NULL, NULL, label, server);
}
/*
@@ -5883,7 +5991,7 @@ static int nfs4_xdr_dec_open_downgrade(struct rpc_rqst *rqstp,
status = decode_open_downgrade(xdr, res);
if (status != 0)
goto out;
- decode_getfattr(xdr, res->fattr, res->server);
+ decode_getfattr(xdr, res->fattr, res->label, res->server);
out:
return status;
}
@@ -5909,7 +6017,7 @@ static int nfs4_xdr_dec_access(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
status = decode_access(xdr, &res->supported, &res->access);
if (status != 0)
goto out;
- decode_getfattr(xdr, res->fattr, res->server);
+ decode_getfattr(xdr, res->fattr, res->label, res->server);
out:
return status;
}
@@ -5938,7 +6046,7 @@ static int nfs4_xdr_dec_lookup(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
status = decode_getfh(xdr, res->fh);
if (status)
goto out;
- status = decode_getfattr(xdr, res->fattr, res->server);
+ status = decode_getfattr(xdr, res->fattr, res->label, res->server);
out:
return status;
}
@@ -5964,7 +6072,8 @@ static int nfs4_xdr_dec_lookup_root(struct rpc_rqst *rqstp,
goto out;
status = decode_getfh(xdr, res->fh);
if (status == 0)
- status = decode_getfattr(xdr, res->fattr, res->server);
+ status = decode_getfattr(xdr, res->fattr,
+ res->label, res->server);
out:
return status;
}
@@ -6055,7 +6164,7 @@ static int nfs4_xdr_dec_link(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
status = decode_restorefh(xdr);
if (status)
goto out;
- decode_getfattr(xdr, res->fattr, res->server);
+ decode_getfattr(xdr, res->fattr, res->label, res->server);
out:
return status;
}
@@ -6084,7 +6193,7 @@ static int nfs4_xdr_dec_create(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
status = decode_getfh(xdr, res->fh);
if (status)
goto out;
- decode_getfattr(xdr, res->fattr, res->server);
+ decode_getfattr(xdr, res->fattr, res->label, res->server);
out:
return status;
}
@@ -6116,7 +6225,7 @@ static int nfs4_xdr_dec_getattr(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
status = decode_putfh(xdr);
if (status)
goto out;
- status = decode_getfattr(xdr, res->fattr, res->server);
+ status = decode_getfattr(xdr, res->fattr, res->label, res->server);
out:
return status;
}
@@ -6218,7 +6327,7 @@ static int nfs4_xdr_dec_close(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
* an ESTALE error. Shouldn't be a problem,
* though, since fattr->valid will remain unset.
*/
- decode_getfattr(xdr, res->fattr, res->server);
+ decode_getfattr(xdr, res->fattr, res->label, res->server);
out:
return status;
}
@@ -6249,7 +6358,7 @@ static int nfs4_xdr_dec_open(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
goto out;
if (res->access_request)
decode_access(xdr, &res->access_supported, &res->access_result);
- decode_getfattr(xdr, res->f_attr, res->server);
+ decode_getfattr(xdr, res->f_attr, res->f_label, res->server);
out:
return status;
}
@@ -6299,7 +6408,7 @@ static int nfs4_xdr_dec_open_noattr(struct rpc_rqst *rqstp,
goto out;
if (res->access_request)
decode_access(xdr, &res->access_supported, &res->access_result);
- decode_getfattr(xdr, res->f_attr, res->server);
+ decode_getfattr(xdr, res->f_attr, NULL, res->server);
out:
return status;
}
@@ -6326,7 +6435,7 @@ static int nfs4_xdr_dec_setattr(struct rpc_rqst *rqstp,
status = decode_setattr(xdr);
if (status)
goto out;
- decode_getfattr(xdr, res->fattr, res->server);
+ decode_getfattr(xdr, res->fattr, res->label, res->server);
out:
return status;
}
@@ -6506,7 +6615,7 @@ static int nfs4_xdr_dec_write(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
if (status)
goto out;
if (res->fattr)
- decode_getfattr(xdr, res->fattr, res->server);
+ decode_getfattr(xdr, res->fattr, NULL, res->server);
if (!status)
status = res->count;
out:
@@ -6687,7 +6796,7 @@ static int nfs4_xdr_dec_delegreturn(struct rpc_rqst *rqstp,
status = decode_putfh(xdr);
if (status != 0)
goto out;
- status = decode_getfattr(xdr, res->fattr, res->server);
+ status = decode_getfattr(xdr, res->fattr, res->label, res->server);
if (status != 0)
goto out;
status = decode_delegreturn(xdr);
@@ -6720,7 +6829,7 @@ static int nfs4_xdr_dec_fs_locations(struct rpc_rqst *req,
xdr_enter_page(xdr, PAGE_SIZE);
status = decode_getfattr_generic(xdr, &res->fs_locations->fattr,
NULL, res->fs_locations,
- res->fs_locations->server);
+ NULL, res->fs_locations->server);
out:
return status;
}
@@ -7001,7 +7110,7 @@ static int nfs4_xdr_dec_layoutcommit(struct rpc_rqst *rqstp,
status = decode_layoutcommit(xdr, rqstp, res);
if (status)
goto out;
- decode_getfattr(xdr, res->fattr, res->server);
+ decode_getfattr(xdr, res->fattr, NULL, res->server);
out:
return status;
}
@@ -7133,7 +7242,7 @@ int nfs4_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry,
goto out_overflow;
if (decode_getfattr_attrs(xdr, bitmap, entry->fattr, entry->fh,
- NULL, entry->server) < 0)
+ NULL, entry->label, entry->server) < 0)
goto out_overflow;
if (entry->fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID)
entry->ino = entry->fattr->mounted_on_fileid;
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index c98b434..4e78f93 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -2419,8 +2419,21 @@ static int nfs_bdi_register(struct nfs_server *server)
int nfs_set_sb_security(struct super_block *s, struct dentry *mntroot,
struct nfs_mount_info *mount_info)
{
- return security_sb_set_mnt_opts(s, &mount_info->parsed->lsm_opts,
- 0, NULL);
+ int error;
+ unsigned long kflags = 0, kflags_out = 0;
+ if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL)
+ kflags |= SECURITY_LSM_NATIVE_LABELS;
+
+ error = security_sb_set_mnt_opts(s, &mount_info->parsed->lsm_opts,
+ kflags, &kflags_out);
+ if (error)
+ goto err;
+
+ if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL &&
+ !(kflags_out & SECURITY_LSM_NATIVE_LABELS))
+ NFS_SB(s)->caps &= ~NFS_CAP_SECURITY_LABEL;
+err:
+ return error;
}
EXPORT_SYMBOL_GPL(nfs_set_sb_security);
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 41b0b6d..ff4f72a 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -199,6 +199,7 @@ struct nfs_inode {
#define NFS_INO_INVALID_ACL 0x0010 /* cached acls are invalid */
#define NFS_INO_REVAL_PAGECACHE 0x0020 /* must revalidate pagecache */
#define NFS_INO_REVAL_FORCED 0x0040 /* force revalidation ignoring a delegation */
+#define NFS_INO_INVALID_LABEL 0x0080 /* cached label is invalid */
/*
* Bit offsets in flags field
@@ -344,6 +345,8 @@ extern int __nfs_revalidate_inode(struct nfs_server *, struct inode *);
extern int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping);
extern int nfs_setattr(struct dentry *, struct iattr *);
extern void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr);
+extern void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr,
+ struct nfs4_label *label);
extern struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx);
extern void put_nfs_open_context(struct nfs_open_context *ctx);
extern struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode);
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index e6ed3c2..2a4f1d4 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -145,11 +145,18 @@ struct nfs_server {
u32 attr_bitmask[3];/* V4 bitmask representing the set
of attributes supported on this
filesystem */
+ u32 attr_bitmask_nl[3];
+ /* V4 bitmask representing the
+ set of attributes supported
+ on this filesystem excluding
+ the label support bit. */
u32 cache_consistency_bitmask[3];
/* V4 bitmask representing the subset
of change attribute, size, ctime
and mtime attributes supported by
the server */
+ u32 cache_consistency_bitmask_nl[3];
+ /* As above, excluding label. */
u32 acl_bitmask; /* V4 bitmask representing the ACEs
that are supported on this
filesystem */
diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index dda436f..af947f8 100644
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -2876,7 +2876,10 @@ static void selinux_inode_post_setxattr(struct dentry *dentry, const char *name,
return;
}
+ isec->sclass = inode_mode_to_security_class(inode->i_mode);
isec->sid = newsid;
+ isec->initialized = 1;
+
return;
}
@@ -2964,6 +2967,7 @@ static int selinux_inode_setsecurity(struct inode *inode, const char *name,
if (rc)
return rc;
+ isec->sclass = inode_mode_to_security_class(inode->i_mode);
isec->sid = newsid;
isec->initialized = 1;
return 0;
--
1.7.11.7
^ permalink raw reply related [flat|nested] 58+ messages in thread
* [PATCH 11/15] NFS: Extend NFS xattr handlers to accept the security namespace
2013-02-08 12:39 ` Steve Dickson
` (10 preceding siblings ...)
(?)
@ 2013-02-08 12:39 ` Steve Dickson
-1 siblings, 0 replies; 58+ messages in thread
From: Steve Dickson @ 2013-02-08 12:39 UTC (permalink / raw)
To: Trond Myklebust, J. Bruce Fields, David P. Quigley
Cc: Linux NFS list, Linux FS devel list, Linux Security List, SELinux List
From: David Quigley <dpquigl@davequigley.com>
The existing NFSv4 xattr handlers do not accept xattr calls to the security
namespace. This patch extends these handlers to accept xattrs from the security
namespace in addition to the default NFSv4 ACL namespace.
Signed-off-by: Matthew N. Dodd <Matthew.Dodd@sparta.com>
Signed-off-by: Miguel Rodel Felipe <Rodel_FM@dsi.a-star.edu.sg>
Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene@dsi.a-star.edu.sg>
Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG@dsi.a-star.edu.sg>
---
fs/nfs/nfs4proc.c | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++
security/security.c | 1 +
2 files changed, 51 insertions(+)
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 280bb22..2b026c4 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -5452,6 +5452,53 @@ static size_t nfs4_xattr_list_nfs4_acl(struct dentry *dentry, char *list,
return len;
}
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+static inline int nfs4_server_supports_labels(struct nfs_server *server)
+{
+ return server->caps & NFS_CAP_SECURITY_LABEL;
+}
+
+static int nfs4_xattr_set_nfs4_label(struct dentry *dentry, const char *key,
+ const void *buf, size_t buflen,
+ int flags, int type)
+{
+ if (security_ismaclabel(key))
+ return nfs4_set_security_label(dentry, buf, buflen);
+
+ return -EOPNOTSUPP;
+}
+
+static int nfs4_xattr_get_nfs4_label(struct dentry *dentry, const char *key,
+ void *buf, size_t buflen, int type)
+{
+ if (security_ismaclabel(key))
+ return nfs4_get_security_label(dentry->d_inode, buf, buflen);
+ return -EOPNOTSUPP;
+}
+
+static size_t nfs4_xattr_list_nfs4_label(struct dentry *dentry, char *list,
+ size_t list_len, const char *name,
+ size_t name_len, int type)
+{
+ size_t len = 0;
+
+ if (nfs_server_capable(dentry->d_inode, NFS_CAP_SECURITY_LABEL)) {
+ len = security_inode_listsecurity(dentry->d_inode, NULL, 0);
+ if (list && len <= list_len)
+ security_inode_listsecurity(dentry->d_inode, list, len);
+ }
+ return len;
+}
+
+static const struct xattr_handler nfs4_xattr_nfs4_label_handler = {
+ .prefix = XATTR_SECURITY_PREFIX,
+ .list = nfs4_xattr_list_nfs4_label,
+ .get = nfs4_xattr_get_nfs4_label,
+ .set = nfs4_xattr_set_nfs4_label,
+};
+#endif
+
+
/*
* nfs_fhget will use either the mounted_on_fileid or the fileid
*/
@@ -7190,6 +7237,9 @@ static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = {
const struct xattr_handler *nfs4_xattr_handlers[] = {
&nfs4_xattr_nfs4_acl_handler,
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+ &nfs4_xattr_nfs4_label_handler,
+#endif
NULL
};
diff --git a/security/security.c b/security/security.c
index dd9e4c8..af835e3 100644
--- a/security/security.c
+++ b/security/security.c
@@ -660,6 +660,7 @@ int security_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer
return 0;
return security_ops->inode_listsecurity(inode, buffer, buffer_size);
}
+EXPORT_SYMBOL(security_inode_listsecurity);
void security_inode_getsecid(const struct inode *inode, u32 *secid)
{
--
1.7.11.7
^ permalink raw reply related [flat|nested] 58+ messages in thread
* [PATCH 12/15] lnfs: Do not sleep holding the inode spin lock
2013-02-08 12:39 ` Steve Dickson
` (11 preceding siblings ...)
(?)
@ 2013-02-08 12:39 ` Steve Dickson
[not found] ` <1360327163-20360-13-git-send-email-SteveD-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org>
-1 siblings, 1 reply; 58+ messages in thread
From: Steve Dickson @ 2013-02-08 12:39 UTC (permalink / raw)
To: Trond Myklebust, J. Bruce Fields, David P. Quigley
Cc: Linux NFS list, Linux FS devel list, Linux Security List, SELinux List
From: Dave Quigley <dpquigl@taiga.selinuxproject.org>
The nfs_setsecurity code can sleep while allocating memory
so the inode spin lock can not be held while during this call.
Signed-off-by: Steve Dickson <steved@redhat.com>
---
fs/nfs/inode.c | 10 +++++++---
1 file changed, 7 insertions(+), 3 deletions(-)
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 0d412c4..65bf9ca 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -1285,6 +1285,9 @@ int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr, struct nfs4_
status = nfs_refresh_inode_locked(inode, fattr, label);
spin_unlock(&inode->i_lock);
+ if (label && !status)
+ nfs_setsecurity(inode, fattr, label);
+
return status;
}
EXPORT_SYMBOL_GPL(nfs_refresh_inode);
@@ -1324,6 +1327,10 @@ int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr, struc
spin_lock(&inode->i_lock);
status = nfs_post_op_update_inode_locked(inode, fattr, label);
spin_unlock(&inode->i_lock);
+ if (nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL)) {
+ if (label && !status)
+ nfs_setsecurity(inode, fattr, label);
+ }
return status;
}
EXPORT_SYMBOL_GPL(nfs_post_op_update_inode);
@@ -1543,9 +1550,6 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr, struct
| NFS_INO_INVALID_ACL
| NFS_INO_REVAL_FORCED);
- if (label && (server->caps & NFS_CAP_SECURITY_LABEL))
- nfs_setsecurity(inode, fattr, label);
-
if (fattr->valid & NFS_ATTR_FATTR_NLINK) {
if (inode->i_nlink != fattr->nlink) {
invalid |= NFS_INO_INVALID_ATTR;
--
1.7.11.7
^ permalink raw reply related [flat|nested] 58+ messages in thread
* [PATCH 13/15] Kconfig: Add Kconfig entry for Labeled NFS V4 client
2013-02-08 12:39 ` Steve Dickson
` (12 preceding siblings ...)
(?)
@ 2013-02-08 12:39 ` Steve Dickson
-1 siblings, 0 replies; 58+ messages in thread
From: Steve Dickson @ 2013-02-08 12:39 UTC (permalink / raw)
To: Trond Myklebust, J. Bruce Fields, David P. Quigley
Cc: Linux NFS list, Linux FS devel list, Linux Security List, SELinux List
From: Steve Dickson <steved@redhat.com>
This patch adds the NFS_V4_SECURITY_LABEL entry which
enables security label support for the NFSv4 client
Signed-off-by: Steve Dickson <steved@redhat.com>
---
fs/nfs/Kconfig | 18 ++++++++++++++++++
1 file changed, 18 insertions(+)
diff --git a/fs/nfs/Kconfig b/fs/nfs/Kconfig
index 13ca196..3861a1f 100644
--- a/fs/nfs/Kconfig
+++ b/fs/nfs/Kconfig
@@ -131,6 +131,24 @@ config NFS_V4_1_IMPLEMENTATION_ID_DOMAIN
If the NFS client is unchanged from the upstream kernel, this
option should be set to the default "kernel.org".
+config NFS_V4_SECURITY_LABEL
+ bool "Provide Security Label support for NFSv4 client"
+ depends on NFS_V4 && SECURITY
+ help
+
+ Say Y here if you want enable fine-grained security label attribute
+ support for NFS version 4. Security labels allow security modules like
+ SELinux and Smack to label files to facilitate enforcement of their policies.
+ Without this an NFSv4 mount will have the same label on each file.
+
+ If you do not wish to enable fine-grained security labels SELinux or
+ Smack policies on NFSv4 files, say N.
+
+ WARNING: there is still a chance of backwards-incompatible protocol changes.
+ For now we recommend "Y" only for developers and testers."
+
+ If unsure, say N.
+
config ROOT_NFS
bool "Root file system on NFS"
depends on NFS_FS=y && IP_PNP
--
1.7.11.7
^ permalink raw reply related [flat|nested] 58+ messages in thread
* [PATCH 14/15] NFSD: Server implementation of MAC Labeling
2013-02-08 12:39 ` Steve Dickson
` (13 preceding siblings ...)
(?)
@ 2013-02-08 12:39 ` Steve Dickson
2013-02-12 22:54 ` J. Bruce Fields
-1 siblings, 1 reply; 58+ messages in thread
From: Steve Dickson @ 2013-02-08 12:39 UTC (permalink / raw)
To: Trond Myklebust, J. Bruce Fields, David P. Quigley
Cc: Linux NFS list, Linux FS devel list, Linux Security List, SELinux List
From: David Quigley <dpquigl@davequigley.com>
This patch adds the ability to encode and decode file labels on the server for
the purpose of sending them to the client and also to process label change
requests from the client.
Signed-off-by: Matthew N. Dodd <Matthew.Dodd@sparta.com>
Signed-off-by: Miguel Rodel Felipe <Rodel_FM@dsi.a-star.edu.sg>
Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene@dsi.a-star.edu.sg>
Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG@dsi.a-star.edu.sg>
---
fs/nfsd/nfs4proc.c | 41 +++++++++++++++++++
fs/nfsd/nfs4xdr.c | 116 ++++++++++++++++++++++++++++++++++++++++++++++++++---
fs/nfsd/nfsd.h | 8 ++--
fs/nfsd/vfs.c | 30 ++++++++++++++
fs/nfsd/vfs.h | 2 +
fs/nfsd/xdr4.h | 3 ++
6 files changed, 191 insertions(+), 9 deletions(-)
diff --git a/fs/nfsd/nfs4proc.c b/fs/nfsd/nfs4proc.c
index 9d1c5db..898092d 100644
--- a/fs/nfsd/nfs4proc.c
+++ b/fs/nfsd/nfs4proc.c
@@ -42,6 +42,36 @@
#include "current_stateid.h"
#include "netns.h"
+#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
+#include <linux/security.h>
+
+static inline void
+nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct nfs4_label *label, u32 *bmval)
+{
+ struct inode *inode = resfh->fh_dentry->d_inode;
+ int status;
+
+ mutex_lock(&inode->i_mutex);
+ status = security_inode_setsecctx(resfh->fh_dentry,
+ label->label, label->len);
+ mutex_unlock(&inode->i_mutex);
+
+ if (status)
+ /*
+ * We should probably fail the whole open at this point,
+ * but we've already created or opened the file, so it's
+ * too late; So this seems the least of evils:
+ */
+ bmval[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
+
+ return;
+}
+#else
+static inline void
+nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct nfs4_label *label, u32 *bmval)
+{ }
+#endif
+
#define NFSDDBG_FACILITY NFSDDBG_PROC
static u32 nfsd_attrmask[] = {
@@ -230,6 +260,9 @@ do_open_lookup(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_o
(u32 *)open->op_verf.data,
&open->op_truncate, &open->op_created);
+ if (!status && open->op_label != NULL)
+ nfsd4_security_inode_setsecctx(resfh, open->op_label, open->op_bmval);
+
/*
* Following rfc 3530 14.2.16, use the returned bitmask
* to indicate which attributes we used to store the
@@ -599,6 +632,9 @@ nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
if (status)
goto out;
+ if (create->cr_label != NULL)
+ nfsd4_security_inode_setsecctx(&resfh, create->cr_label, create->cr_bmval);
+
if (create->cr_acl != NULL)
do_set_nfs4_acl(rqstp, &resfh, create->cr_acl,
create->cr_bmval);
@@ -888,6 +924,11 @@ nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
setattr->sa_acl);
if (status)
goto out;
+ if (setattr->sa_label != NULL)
+ status = nfsd4_set_nfs4_label(rqstp, &cstate->current_fh,
+ setattr->sa_label);
+ if (status)
+ goto out;
status = nfsd_setattr(rqstp, &cstate->current_fh, &setattr->sa_iattr,
0, (time_t)0);
out:
diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
index 0dc1158..0124b43 100644
--- a/fs/nfsd/nfs4xdr.c
+++ b/fs/nfsd/nfs4xdr.c
@@ -55,6 +55,11 @@
#include "cache.h"
#include "netns.h"
+#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
+#include <linux/security.h>
+#endif
+
+
#define NFSDDBG_FACILITY NFSDDBG_XDR
/*
@@ -242,7 +247,8 @@ nfsd4_decode_bitmap(struct nfsd4_compoundargs *argp, u32 *bmval)
static __be32
nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval,
- struct iattr *iattr, struct nfs4_acl **acl)
+ struct iattr *iattr, struct nfs4_acl **acl,
+ struct nfs4_label **label)
{
int expected_len, len = 0;
u32 dummy32;
@@ -386,6 +392,50 @@ nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval,
goto xdr_error;
}
}
+#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
+ if (bmval[2] & FATTR4_WORD2_SECURITY_LABEL) {
+ uint32_t pi;
+ uint32_t lfs;
+
+ READ_BUF(4);
+ len += 4;
+ READ32(lfs);
+ READ_BUF(4);
+ len += 4;
+ READ32(pi);
+ READ_BUF(4);
+ len += 4;
+ READ32(dummy32);
+ READ_BUF(dummy32);
+ len += (XDR_QUADLEN(dummy32) << 2);
+ READMEM(buf, dummy32);
+
+ if (dummy32 > NFS4_MAXLABELLEN)
+ return nfserr_resource;
+
+ *label = kzalloc(sizeof(struct nfs4_label), GFP_KERNEL);
+ if (*label == NULL) {
+ host_err = -ENOMEM;
+ goto out_nfserr;
+ }
+
+ (*label)->label = kmalloc(dummy32 + 1, GFP_KERNEL);
+ if ((*label)->label == NULL) {
+ host_err = -ENOMEM;
+ kfree(*label);
+ goto out_nfserr;
+ }
+
+ (*label)->len = dummy32;
+ memcpy((*label)->label, buf, dummy32);
+ ((char *)(*label)->label)[dummy32] = '\0';
+ (*label)->pi = pi;
+ (*label)->lfs = lfs;
+
+ defer_free(argp, kfree, (*label)->label);
+ defer_free(argp, kfree, *label);
+ }
+#endif
if (bmval[0] & ~NFSD_WRITEABLE_ATTRS_WORD0
|| bmval[1] & ~NFSD_WRITEABLE_ATTRS_WORD1
|| bmval[2] & ~NFSD_WRITEABLE_ATTRS_WORD2)
@@ -575,7 +625,7 @@ nfsd4_decode_create(struct nfsd4_compoundargs *argp, struct nfsd4_create *create
return status;
status = nfsd4_decode_fattr(argp, create->cr_bmval, &create->cr_iattr,
- &create->cr_acl);
+ &create->cr_acl, &create->cr_label);
if (status)
goto out;
@@ -825,7 +875,7 @@ nfsd4_decode_open(struct nfsd4_compoundargs *argp, struct nfsd4_open *open)
case NFS4_CREATE_UNCHECKED:
case NFS4_CREATE_GUARDED:
status = nfsd4_decode_fattr(argp, open->op_bmval,
- &open->op_iattr, &open->op_acl);
+ &open->op_iattr, &open->op_acl, &open->op_label);
if (status)
goto out;
break;
@@ -839,7 +889,7 @@ nfsd4_decode_open(struct nfsd4_compoundargs *argp, struct nfsd4_open *open)
READ_BUF(NFS4_VERIFIER_SIZE);
COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE);
status = nfsd4_decode_fattr(argp, open->op_bmval,
- &open->op_iattr, &open->op_acl);
+ &open->op_iattr, &open->op_acl, &open->op_label);
if (status)
goto out;
break;
@@ -1061,7 +1111,7 @@ nfsd4_decode_setattr(struct nfsd4_compoundargs *argp, struct nfsd4_setattr *seta
if (status)
return status;
return nfsd4_decode_fattr(argp, setattr->sa_bmval, &setattr->sa_iattr,
- &setattr->sa_acl);
+ &setattr->sa_acl, &setattr->sa_label);
}
static __be32
@@ -1970,6 +2020,50 @@ nfsd4_encode_aclname(struct svc_rqst *rqstp, int whotype, uid_t id, int group,
FATTR4_WORD0_RDATTR_ERROR)
#define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID
+#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
+static inline __be32
+nfsd4_encode_security_label(struct svc_rqst *rqstp, struct dentry *dentry, __be32 **pp, int *buflen)
+{
+ void *context;
+ int err;
+ int len;
+ uint32_t pi = 0;
+ uint32_t lfs = 0;
+ __be32 *p = *pp;
+
+ err = 0;
+ (void)security_inode_getsecctx(dentry->d_inode, &context, &len);
+ if (len < 0)
+ return nfserrno(len);
+
+ if (*buflen < ((XDR_QUADLEN(len) << 2) + 4 + 4 + 4)) {
+ err = nfserr_resource;
+ goto out;
+ }
+
+ /* XXX: A call to the translation code should be placed here
+ * for now send 0 until we have that to indicate the null
+ * translation */
+
+ if ((*buflen -= 4) < 0)
+ return nfserr_resource;
+
+ WRITE32(lfs);
+ WRITE32(pi);
+ p = xdr_encode_opaque(p, context, len);
+ *buflen -= (XDR_QUADLEN(len) << 2) + 4;
+
+ *pp = p;
+out:
+ security_release_secctx(context, len);
+ return err;
+}
+#else
+static inline __be32
+nfsd4_encode_security_label(struct svc_rqst *rqstp, struct dentry *dentry, __be32 **pp, int *buflen)
+{ return 0; }
+#endif
+
static __be32 fattr_handle_absent_fs(u32 *bmval0, u32 *bmval1, u32 *rdattr_err)
{
/* As per referral draft: */
@@ -2111,6 +2205,10 @@ nfsd4_encode_fattr(struct svc_fh *fhp, struct svc_export *exp,
if (!aclsupport)
word0 &= ~FATTR4_WORD0_ACL;
+#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
+ if (word2)
+ word2 |= FATTR4_WORD2_SECURITY_LABEL;
+#endif
if (!word2) {
if ((buflen -= 12) < 0)
goto out_resource;
@@ -2423,6 +2521,14 @@ out_acl:
get_parent_attributes(exp, &stat);
WRITE64(stat.ino);
}
+ if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) {
+ status = nfsd4_encode_security_label(rqstp, dentry,
+ &p, &buflen);
+ if (status == nfserr_resource)
+ goto out_resource;
+ if (status)
+ goto out;
+ }
if (bmval2 & FATTR4_WORD2_SUPPATTR_EXCLCREAT) {
WRITE32(3);
WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD0);
diff --git a/fs/nfsd/nfsd.h b/fs/nfsd/nfsd.h
index de23db2..727fe44 100644
--- a/fs/nfsd/nfsd.h
+++ b/fs/nfsd/nfsd.h
@@ -308,10 +308,10 @@ void nfsd_lockd_shutdown(void);
| FATTR4_WORD1_OWNER | FATTR4_WORD1_OWNER_GROUP | FATTR4_WORD1_RAWDEV \
| FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE | FATTR4_WORD1_SPACE_TOTAL \
| FATTR4_WORD1_SPACE_USED | FATTR4_WORD1_TIME_ACCESS | FATTR4_WORD1_TIME_ACCESS_SET \
- | FATTR4_WORD1_TIME_DELTA | FATTR4_WORD1_TIME_METADATA \
- | FATTR4_WORD1_TIME_MODIFY | FATTR4_WORD1_TIME_MODIFY_SET | FATTR4_WORD1_MOUNTED_ON_FILEID)
+ | FATTR4_WORD1_TIME_DELTA | FATTR4_WORD1_TIME_METADATA | FATTR4_WORD1_TIME_MODIFY \
+ | FATTR4_WORD1_TIME_MODIFY_SET | FATTR4_WORD1_MOUNTED_ON_FILEID)
-#define NFSD4_SUPPORTED_ATTRS_WORD2 0
+#define NFSD4_SUPPORTED_ATTRS_WORD2 FATTR4_WORD2_SECURITY_LABEL
#define NFSD4_1_SUPPORTED_ATTRS_WORD0 \
NFSD4_SUPPORTED_ATTRS_WORD0
@@ -350,7 +350,7 @@ static inline u32 nfsd_suppattrs2(u32 minorversion)
#define NFSD_WRITEABLE_ATTRS_WORD1 \
(FATTR4_WORD1_MODE | FATTR4_WORD1_OWNER | FATTR4_WORD1_OWNER_GROUP \
| FATTR4_WORD1_TIME_ACCESS_SET | FATTR4_WORD1_TIME_MODIFY_SET)
-#define NFSD_WRITEABLE_ATTRS_WORD2 0
+#define NFSD_WRITEABLE_ATTRS_WORD2 FATTR4_WORD2_SECURITY_LABEL
#define NFSD_SUPPATTR_EXCLCREAT_WORD0 \
NFSD_WRITEABLE_ATTRS_WORD0
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index d586117..0567fdc 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -28,6 +28,7 @@
#include <asm/uaccess.h>
#include <linux/exportfs.h>
#include <linux/writeback.h>
+#include <linux/security.h>
#ifdef CONFIG_NFSD_V3
#include "xdr3.h"
@@ -621,6 +622,35 @@ int nfsd4_is_junction(struct dentry *dentry)
return 0;
return 1;
}
+#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
+__be32 nfsd4_set_nfs4_label(struct svc_rqst *rqstp, struct svc_fh *fhp,
+ struct nfs4_label *label)
+{
+ __be32 error;
+ int host_error;
+ struct dentry *dentry;
+
+ /* Get inode */
+ /* XXX: should we have a MAY_SSECCTX? */
+ error = fh_verify(rqstp, fhp, 0 /* S_IFREG */, NFSD_MAY_SATTR);
+ if (error)
+ return error;
+
+ dentry = fhp->fh_dentry;
+
+ mutex_lock(&dentry->d_inode->i_mutex);
+ host_error = security_inode_setsecctx(dentry, label->label, label->len);
+ mutex_unlock(&dentry->d_inode->i_mutex);
+ return nfserrno(host_error);
+}
+#else
+__be32 nfsd4_set_nfs4_label(struct svc_rqst *rqstp, struct svc_fh *fhp,
+ struct nfs4_label *label)
+{
+ return -EOPNOTSUPP;
+}
+#endif
+
#endif /* defined(CONFIG_NFSD_V4) */
#ifdef CONFIG_NFSD_V3
diff --git a/fs/nfsd/vfs.h b/fs/nfsd/vfs.h
index 359594c..49c6cc0 100644
--- a/fs/nfsd/vfs.h
+++ b/fs/nfsd/vfs.h
@@ -55,6 +55,8 @@ int nfsd_mountpoint(struct dentry *, struct svc_export *);
__be32 nfsd4_set_nfs4_acl(struct svc_rqst *, struct svc_fh *,
struct nfs4_acl *);
int nfsd4_get_nfs4_acl(struct svc_rqst *, struct dentry *, struct nfs4_acl **);
+__be32 nfsd4_set_nfs4_label(struct svc_rqst *, struct svc_fh *,
+ struct nfs4_label *);
#endif /* CONFIG_NFSD_V4 */
__be32 nfsd_create(struct svc_rqst *, struct svc_fh *,
char *name, int len, struct iattr *attrs,
diff --git a/fs/nfsd/xdr4.h b/fs/nfsd/xdr4.h
index 0889bfb..9e7e663 100644
--- a/fs/nfsd/xdr4.h
+++ b/fs/nfsd/xdr4.h
@@ -118,6 +118,7 @@ struct nfsd4_create {
struct iattr cr_iattr; /* request */
struct nfsd4_change_info cr_cinfo; /* response */
struct nfs4_acl *cr_acl;
+ struct nfs4_label *cr_label;
};
#define cr_linklen u.link.namelen
#define cr_linkname u.link.name
@@ -246,6 +247,7 @@ struct nfsd4_open {
struct nfs4_file *op_file; /* used during processing */
struct nfs4_ol_stateid *op_stp; /* used during processing */
struct nfs4_acl *op_acl;
+ struct nfs4_label *op_label;
};
#define op_iattr iattr
@@ -330,6 +332,7 @@ struct nfsd4_setattr {
u32 sa_bmval[3]; /* request */
struct iattr sa_iattr; /* request */
struct nfs4_acl *sa_acl;
+ struct nfs4_label *sa_label;
};
struct nfsd4_setclientid {
--
1.7.11.7
^ permalink raw reply related [flat|nested] 58+ messages in thread
* [PATCH 15/15] Kconfig: Add Kconfig entry for Labeled NFS V4 server
2013-02-08 12:39 ` Steve Dickson
` (14 preceding siblings ...)
(?)
@ 2013-02-08 12:39 ` Steve Dickson
-1 siblings, 0 replies; 58+ messages in thread
From: Steve Dickson @ 2013-02-08 12:39 UTC (permalink / raw)
To: Trond Myklebust, J. Bruce Fields, David P. Quigley
Cc: Linux NFS list, Linux FS devel list, Linux Security List, SELinux List
From: Steve Dickson <steved@redhat.com>
This patch adds the NFSd_V4_SECURITY_LABEL entry which
enables security label support for the NFSv4 server
Signed-off-by: Steve Dickson <steved@redhat.com>
---
fs/nfsd/Kconfig | 16 ++++++++++++++++
1 file changed, 16 insertions(+)
diff --git a/fs/nfsd/Kconfig b/fs/nfsd/Kconfig
index 8df1ea4..a569dc1 100644
--- a/fs/nfsd/Kconfig
+++ b/fs/nfsd/Kconfig
@@ -81,6 +81,22 @@ config NFSD_V4
If unsure, say N.
+config NFSD_V4_SECURITY_LABEL
+ bool "Provide Security Label support for NFSv4 server"
+ depends on NFSD_V4 && SECURITY
+ help
+
+ Say Y here if you want enable fine-grained security label attribute
+ support for NFS version 4. Security labels allow security modules like
+ SELinux and Smack to label files to facilitate enforcement of their policies.
+ Without this an NFSv4 mount will have the same label on each file.
+
+ If you do not wish to enable fine-grained security labels SELinux or
+ Smack policies on NFSv4 files, say N.
+
+ WARNING: there is still a chance of backwards-incompatible protocol changes.
+ For now we recommend "Y" only for developers and testers."
+
config NFSD_FAULT_INJECTION
bool "NFS server manual fault injection"
depends on NFSD_V4 && DEBUG_KERNEL
--
1.7.11.7
^ permalink raw reply related [flat|nested] 58+ messages in thread
* Re: [PATCH 00/15] lnfs: 3.8-rc6 release
2013-02-08 12:39 ` Steve Dickson
` (15 preceding siblings ...)
(?)
@ 2013-02-12 21:41 ` J. Bruce Fields
2013-02-12 22:02 ` Casey Schaufler
-1 siblings, 1 reply; 58+ messages in thread
From: J. Bruce Fields @ 2013-02-12 21:41 UTC (permalink / raw)
To: Steve Dickson
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On Fri, Feb 08, 2013 at 07:39:08AM -0500, Steve Dickson wrote:
> include/linux/security.h | 57 +++-
...
> security/capability.c | 19 +-
> security/security.c | 24 +-
> security/selinux/hooks.c | 92 +++++-
> security/selinux/include/security.h | 2 +
> security/selinux/ss/policydb.c | 5 +-
> security/smack/smack_lsm.c | 11 +
> 33 files changed, 1352 insertions(+), 214 deletions(-)
Are we still waiting on ACKs from the security people for these bits?
--b.
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 00/15] lnfs: 3.8-rc6 release
2013-02-12 21:41 ` [PATCH 00/15] lnfs: 3.8-rc6 release J. Bruce Fields
@ 2013-02-12 22:02 ` Casey Schaufler
0 siblings, 0 replies; 58+ messages in thread
From: Casey Schaufler @ 2013-02-12 22:02 UTC (permalink / raw)
To: J. Bruce Fields
Cc: Steve Dickson, Trond Myklebust, J. Bruce Fields,
David P. Quigley, Linux NFS list, Linux FS devel list,
Linux Security List, SELinux List, Casey Schaufler
On 2/12/2013 1:41 PM, J. Bruce Fields wrote:
> On Fri, Feb 08, 2013 at 07:39:08AM -0500, Steve Dickson wrote:
>> include/linux/security.h | 57 +++-
> ...
>> security/capability.c | 19 +-
>> security/security.c | 24 +-
>> security/selinux/hooks.c | 92 +++++-
>> security/selinux/include/security.h | 2 +
>> security/selinux/ss/policydb.c | 5 +-
>> security/smack/smack_lsm.c | 11 +
>> 33 files changed, 1352 insertions(+), 214 deletions(-)
> Are we still waiting on ACKs from the security people for these bits?
I'm not going to NAK it, because I don't know it won't work,
but I'm not going to ACK it either, because I have not been
able to get it to work. I have no idea what the problem
might be, and the "obvious" things we've tried have proven
ineffective. I may have a bad set of user space tools. There
may be more work on Smack hooks required. I can't tell, and
there's way too much NFS set-up involved to make progress in
the limited time I have available.
If you're waiting for my ACK, no, you don't have it.
If you're OK with a lack of NAK, go ahead. There will
be changes someday I suspect, but I can't put this high
enough on my priorities to devote the time required
just now.
>
> --b.
> --
> To unsubscribe from this list: send the line "unsubscribe linux-security-module" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
>
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 00/15] lnfs: 3.8-rc6 release
@ 2013-02-12 22:02 ` Casey Schaufler
0 siblings, 0 replies; 58+ messages in thread
From: Casey Schaufler @ 2013-02-12 22:02 UTC (permalink / raw)
To: J. Bruce Fields
Cc: Steve Dickson, Trond Myklebust, J. Bruce Fields,
David P. Quigley, Linux NFS list, Linux FS devel list,
Linux Security List, SELinux List, Casey Schaufler
On 2/12/2013 1:41 PM, J. Bruce Fields wrote:
> On Fri, Feb 08, 2013 at 07:39:08AM -0500, Steve Dickson wrote:
>> include/linux/security.h | 57 +++-
> ...
>> security/capability.c | 19 +-
>> security/security.c | 24 +-
>> security/selinux/hooks.c | 92 +++++-
>> security/selinux/include/security.h | 2 +
>> security/selinux/ss/policydb.c | 5 +-
>> security/smack/smack_lsm.c | 11 +
>> 33 files changed, 1352 insertions(+), 214 deletions(-)
> Are we still waiting on ACKs from the security people for these bits?
I'm not going to NAK it, because I don't know it won't work,
but I'm not going to ACK it either, because I have not been
able to get it to work. I have no idea what the problem
might be, and the "obvious" things we've tried have proven
ineffective. I may have a bad set of user space tools. There
may be more work on Smack hooks required. I can't tell, and
there's way too much NFS set-up involved to make progress in
the limited time I have available.
If you're waiting for my ACK, no, you don't have it.
If you're OK with a lack of NAK, go ahead. There will
be changes someday I suspect, but I can't put this high
enough on my priorities to devote the time required
just now.
>
> --b.
> --
> To unsubscribe from this list: send the line "unsubscribe linux-security-module" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
>
--
This message was distributed to subscribers of the selinux mailing list.
If you no longer wish to subscribe, send mail to majordomo@tycho.nsa.gov with
the words "unsubscribe selinux" without quotes as the message.
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 06/15] NFSv4: Introduce new label structure
2013-02-08 12:39 ` [PATCH 06/15] NFSv4: Introduce new label structure Steve Dickson
@ 2013-02-12 22:07 ` J. Bruce Fields
[not found] ` <20130212220741.GJ10267-uC3wQj2KruNg9hUCZPvPmw@public.gmane.org>
0 siblings, 1 reply; 58+ messages in thread
From: J. Bruce Fields @ 2013-02-12 22:07 UTC (permalink / raw)
To: Steve Dickson
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On Fri, Feb 08, 2013 at 07:39:14AM -0500, Steve Dickson wrote:
> From: David Quigley <dpquigl@davequigley.com>
>
> In order to mimic the way that NFSv4 ACLs are implemented we have created a
> structure to be used to pass label data up and down the call chain. This patch
> adds the new structure and new members to the required NFSv4 call structures.
>
> Signed-off-by: Matthew N. Dodd <Matthew.Dodd@sparta.com>
> Signed-off-by: Miguel Rodel Felipe <Rodel_FM@dsi.a-star.edu.sg>
> Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene@dsi.a-star.edu.sg>
> Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG@dsi.a-star.edu.sg>
> ---
> fs/nfs/inode.c | 33 +++++++++++++++++++++++++++++++++
> include/linux/nfs4.h | 7 +++++++
> include/linux/nfs_fs.h | 17 +++++++++++++++++
> include/linux/nfs_xdr.h | 21 +++++++++++++++++++++
> include/uapi/linux/nfs4.h | 2 +-
> 5 files changed, 79 insertions(+), 1 deletion(-)
>
> diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
> index ebeb94c..8d5f01b 100644
> --- a/fs/nfs/inode.c
> +++ b/fs/nfs/inode.c
> @@ -255,6 +255,39 @@ nfs_init_locked(struct inode *inode, void *opaque)
> return 0;
> }
>
> +#ifdef CONFIG_NFS_V4_SECURITY_LABEL
> +struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags)
> +{
> + struct nfs4_label *label = NULL;
> +
> + if (!(server->caps & NFS_CAP_SECURITY_LABEL))
> + return label;
> +
> + label = kzalloc(NFS4_MAXLABELLEN, flags);
> + if (label == NULL)
> + return ERR_PTR(-ENOMEM);
> +
> + label->label = (char *)(label + 1);
> + label->len = NFS4_MAXLABELLEN;
If you're expecting to be able to store up to NFS4_MAXLABELLEN of data
after the end of the struct, then you want:
label = kzalloc(sizeof(struct nfs4_label) + NFS4_MAXLABELLEN, flags);
> +
> + return label;
> +}
> +EXPORT_SYMBOL_GPL(nfs4_label_alloc);
> +
> +void nfs4_label_init(struct nfs4_label *label)
> +{
> + if (label && label->label) {
> + /* 0 is the null format meaning that the data is not
> + to be translated */
> + label->lfs = 0;
> + label->pi = 0;
> + label->len = NFS4_MAXLABELLEN;
This logic seems a little odd to me; why would we pass NULL to this?
Why would we skip the other initialization in the !label->label case?
Why is NFS4_MAXLABELLEN the default? (And wasn't that just set in
nfs4_label_alloc?)
But OK maybe I need to read the rest of the patches.
> + }
> + return;
> +}
> +EXPORT_SYMBOL_GPL(nfs4_label_init);
> +#endif
> diff --git a/include/uapi/linux/nfs4.h b/include/uapi/linux/nfs4.h
> index 788128e..b8014a2 100644
> --- a/include/uapi/linux/nfs4.h
> +++ b/include/uapi/linux/nfs4.h
> @@ -25,7 +25,7 @@
> #define NFS4_MAXNAMLEN NAME_MAX
> #define NFS4_OPAQUE_LIMIT 1024
> #define NFS4_MAX_SESSIONID_LEN 16
> -
> +#define NFS4_MAXLABELLEN (4095 - offsetof(struct nfs4_label , label))
The way you've defined things, that should be just
(4095 - sizeof(struct nfs4_label))
(Is there typically some more alloc overhead that would push this
allocation over 4k? I don't know well enough how the allocator(s) work
to answer that.)
--b.
> #define NFS4_ACCESS_READ 0x0001
> #define NFS4_ACCESS_LOOKUP 0x0002
> #define NFS4_ACCESS_MODIFY 0x0004
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 00/15] lnfs: 3.8-rc6 release
2013-02-12 22:02 ` Casey Schaufler
(?)
@ 2013-02-12 22:13 ` J. Bruce Fields
-1 siblings, 0 replies; 58+ messages in thread
From: J. Bruce Fields @ 2013-02-12 22:13 UTC (permalink / raw)
To: Casey Schaufler
Cc: J. Bruce Fields, Steve Dickson, Trond Myklebust,
David P. Quigley, Linux NFS list, Linux FS devel list,
Linux Security List, SELinux List
On Tue, Feb 12, 2013 at 02:02:49PM -0800, Casey Schaufler wrote:
> On 2/12/2013 1:41 PM, J. Bruce Fields wrote:
> > On Fri, Feb 08, 2013 at 07:39:08AM -0500, Steve Dickson wrote:
> >> include/linux/security.h | 57 +++-
> > ...
> >> security/capability.c | 19 +-
> >> security/security.c | 24 +-
> >> security/selinux/hooks.c | 92 +++++-
> >> security/selinux/include/security.h | 2 +
> >> security/selinux/ss/policydb.c | 5 +-
> >> security/smack/smack_lsm.c | 11 +
> >> 33 files changed, 1352 insertions(+), 214 deletions(-)
> > Are we still waiting on ACKs from the security people for these bits?
>
> I'm not going to NAK it, because I don't know it won't work,
> but I'm not going to ACK it either, because I have not been
> able to get it to work. I have no idea what the problem
> might be, and the "obvious" things we've tried have proven
> ineffective. I may have a bad set of user space tools. There
> may be more work on Smack hooks required. I can't tell, and
> there's way too much NFS set-up involved to make progress in
> the limited time I have available.
>
> If you're waiting for my ACK, no, you don't have it.
> If you're OK with a lack of NAK, go ahead. There will
> be changes someday I suspect, but I can't put this high
> enough on my priorities to devote the time required
> just now.
OK, completely understood.
We need someone to ack the security and selinux pieces, though. (That
would be James, Stephen, or Eric?)
--b.
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 09/15] NFS: Add label lifecycle management
2013-02-08 12:39 ` [PATCH 09/15] NFS: Add label lifecycle management Steve Dickson
@ 2013-02-12 22:27 ` J. Bruce Fields
2013-02-16 20:28 ` Steve Dickson
0 siblings, 1 reply; 58+ messages in thread
From: J. Bruce Fields @ 2013-02-12 22:27 UTC (permalink / raw)
To: Steve Dickson
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On Fri, Feb 08, 2013 at 07:39:17AM -0500, Steve Dickson wrote:
> From: Dave Quigley <dpquigl@taiga.selinuxproject.org>
>
> >From David Quigley <dpquigl@davequigley.com>
>
> This patch adds the lifecycle management for the security label structure
> introduced in an earlier patch. The label is not used yet but allocations and
> freeing of the structure is handled.
>
> Signed-off-by: Matthew N. Dodd <Matthew.Dodd@sparta.com>
> Signed-off-by: Miguel Rodel Felipe <Rodel_FM@dsi.a-star.edu.sg>
> Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene@dsi.a-star.edu.sg>
> Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG@dsi.a-star.edu.sg>
> ---
> fs/nfs/dir.c | 23 +++++++++++-
> fs/nfs/inode.c | 15 ++++++--
> fs/nfs/nfs4proc.c | 102 ++++++++++++++++++++++++++++++++++++++++++++++++++----
> 3 files changed, 129 insertions(+), 11 deletions(-)
>
> diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
> index 7003931..d81b7e3 100644
> --- a/fs/nfs/dir.c
> +++ b/fs/nfs/dir.c
> @@ -585,10 +585,16 @@ int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page,
> if (entry.fh == NULL || entry.fattr == NULL)
> goto out;
>
> + entry.label = nfs4_label_alloc(NFS_SERVER(inode), GFP_NOWAIT);
> + if (IS_ERR(entry.label)) {
> + status = PTR_ERR(entry.label);
> + goto out;
> + }
> +
> array = nfs_readdir_get_array(page);
> if (IS_ERR(array)) {
> status = PTR_ERR(array);
> - goto out;
> + goto out_label_free;
> }
> memset(array, 0, sizeof(struct nfs_cache_array));
> array->eof_index = -1;
> @@ -614,6 +620,8 @@ int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page,
> nfs_readdir_free_large_page(pages_ptr, pages, array_size);
> out_release_array:
> nfs_readdir_release_array(page);
> +out_label_free:
> + nfs4_label_free(entry.label);
> out:
> nfs_free_fattr(entry.fattr);
> nfs_free_fhandle(entry.fh);
> @@ -1083,6 +1091,10 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
> if (fhandle == NULL || fattr == NULL)
> goto out_error;
>
> + label = nfs4_label_alloc(NFS_SERVER(inode), GFP_NOWAIT);
> + if (IS_ERR(label))
> + goto out_error;
> +
> error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, label);
> if (error)
> goto out_bad;
> @@ -1093,6 +1105,8 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
>
> nfs_free_fattr(fattr);
> nfs_free_fhandle(fhandle);
> + nfs4_label_free(label);
> +
> out_set_verifier:
> nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
> out_valid:
> @@ -1109,6 +1123,7 @@ out_zap_parent:
> out_bad:
> nfs_free_fattr(fattr);
> nfs_free_fhandle(fhandle);
> + nfs4_label_free(label);
> nfs_mark_for_revalidate(dir);
> if (inode && S_ISDIR(inode->i_mode)) {
> /* Purge readdir caches. */
> @@ -1129,6 +1144,7 @@ out_zap_parent:
> out_error:
> nfs_free_fattr(fattr);
> nfs_free_fhandle(fhandle);
> + nfs4_label_free(label);
> dput(parent);
> dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) lookup returned error %d\n",
> __func__, dentry->d_parent->d_name.name,
> @@ -1244,6 +1260,10 @@ struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned in
> if (fhandle == NULL || fattr == NULL)
> goto out;
>
> + label = nfs4_label_alloc(NFS_SERVER(dir), GFP_NOWAIT);
> + if (IS_ERR(label))
> + goto out;
> +
> parent = dentry->d_parent;
> /* Protect against concurrent sillydeletes */
> nfs_block_sillyrename(parent);
> @@ -1272,6 +1292,7 @@ no_entry:
> nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
> out_unblock_sillyrename:
> nfs_unblock_sillyrename(parent);
> + nfs4_label_free(label);
> out:
> nfs_free_fattr(fattr);
> nfs_free_fhandle(fhandle);
> diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
> index 6b315a0..0cb67cf 100644
> --- a/fs/nfs/inode.c
> +++ b/fs/nfs/inode.c
> @@ -840,6 +840,13 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
> goto out;
>
> nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
> +
> + label = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
> + if (IS_ERR(label)) {
> + status = PTR_ERR(label);
> + goto out;
> + }
> +
> status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr, label);
> if (status != 0) {
> dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n",
> @@ -850,7 +857,7 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
> if (!S_ISDIR(inode->i_mode))
> set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
> }
> - goto out;
> + goto err_out;
> }
>
> status = nfs_refresh_inode(inode, fattr, label);
> @@ -858,7 +865,7 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
> dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n",
> inode->i_sb->s_id,
> (long long)NFS_FILEID(inode), status);
> - goto out;
> + goto err_out;
> }
>
> if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
> @@ -868,7 +875,9 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
> inode->i_sb->s_id,
> (long long)NFS_FILEID(inode));
>
> - out:
> +err_out:
> + nfs4_label_free(label);
> +out:
> nfs_free_fattr(fattr);
> return status;
> }
> diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
> index 4488373..5c9233d1 100644
> --- a/fs/nfs/nfs4proc.c
> +++ b/fs/nfs/nfs4proc.c
> @@ -786,9 +786,14 @@ static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
> p = kzalloc(sizeof(*p), gfp_mask);
> if (p == NULL)
> goto err;
> +
> + p->f_label = nfs4_label_alloc(server, gfp_mask);
> + if (IS_ERR(p->f_label))
> + goto err_free_p;
> +
> p->o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid, gfp_mask);
> if (p->o_arg.seqid == NULL)
> - goto err_free;
> + goto err_free_label;
> nfs_sb_active(dentry->d_sb);
> p->dentry = dget(dentry);
> p->dir = parent;
> @@ -831,7 +836,10 @@ static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
> nfs4_init_opendata_res(p);
> kref_init(&p->kref);
> return p;
> -err_free:
> +
> +err_free_label:
> + nfs4_label_free(p->f_label);
> +err_free_p:
> kfree(p);
> err:
> dput(parent);
> @@ -848,6 +856,9 @@ static void nfs4_opendata_free(struct kref *kref)
> if (p->state != NULL)
> nfs4_put_open_state(p->state);
> nfs4_put_state_owner(p->owner);
> +
> + nfs4_label_free(p->f_label);
> +
> dput(p->dir);
> dput(p->dentry);
> nfs_sb_deactive(sb);
> @@ -1886,6 +1897,14 @@ static int _nfs4_do_open(struct inode *dir,
> if (opendata == NULL)
> goto err_put_state_owner;
>
> + if (label) {
> + olabel = nfs4_label_alloc(server, GFP_KERNEL);
> + if (IS_ERR(olabel)) {
> + status = PTR_ERR(olabel);
> + goto err_opendata_put;
> + }
> + }
> +
> if (ctx_th && server->attr_bitmask[2] & FATTR4_WORD2_MDSTHRESHOLD) {
> opendata->f_attr.mdsthreshold = pnfs_mdsthreshold_alloc();
> if (!opendata->f_attr.mdsthreshold)
> @@ -1897,18 +1916,18 @@ static int _nfs4_do_open(struct inode *dir,
>
> status = _nfs4_proc_open(opendata);
> if (status != 0)
> - goto err_opendata_put;
> + goto err_free_label;
>
> state = nfs4_opendata_to_nfs4_state(opendata);
> status = PTR_ERR(state);
> if (IS_ERR(state))
> - goto err_opendata_put;
> + goto err_free_label;
> if (server->caps & NFS_CAP_POSIX_LOCK)
> set_bit(NFS_STATE_POSIX_LOCKS, &state->flags);
>
> status = nfs4_opendata_access(cred, opendata, state, fmode, flags);
> if (status != 0)
> - goto err_opendata_put;
> + goto err_free_label;
>
> if (opendata->o_arg.open_flags & O_EXCL) {
> nfs4_exclusive_attrset(opendata, sattr);
> @@ -1929,10 +1948,14 @@ static int _nfs4_do_open(struct inode *dir,
> kfree(opendata->f_attr.mdsthreshold);
> opendata->f_attr.mdsthreshold = NULL;
>
> + nfs4_label_free(olabel);
> +
> nfs4_opendata_put(opendata);
> nfs4_put_state_owner(sp);
> *res = state;
> return 0;
> +err_free_label:
> + nfs4_label_free(olabel);
> err_opendata_put:
> kfree(opendata->f_attr.mdsthreshold);
> nfs4_opendata_put(opendata);
> @@ -2496,16 +2519,23 @@ static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *mntfh,
> return error;
> }
>
> + label = nfs4_label_alloc(server, GFP_KERNEL);
> + if (IS_ERR(label))
> + return PTR_ERR(label);
> +
> error = nfs4_proc_getattr(server, mntfh, fattr, label);
> if (error < 0) {
> dprintk("nfs4_get_root: getattr error = %d\n", -error);
> - return error;
> + goto err_free_label;
> }
>
> if (fattr->valid & NFS_ATTR_FATTR_FSID &&
> !nfs_fsid_equal(&server->fsid, &fattr->fsid))
> memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));
>
> +err_free_label:
> + nfs4_label_free(label);
> +
> return error;
> }
>
> @@ -2611,6 +2641,7 @@ nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
> struct inode *inode = dentry->d_inode;
> struct rpc_cred *cred = NULL;
> struct nfs4_state *state = NULL;
> + struct nfs4_label *label = NULL;
> int status;
>
> if (pnfs_ld_layoutret_on_setattr(inode))
> @@ -2637,9 +2668,15 @@ nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
> }
> }
>
> - status = nfs4_do_setattr(inode, cred, fattr, sattr, state, NULL, NULL);
> + label = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
> + if (IS_ERR(label))
> + return PTR_ERR(label);
> +
> + status = nfs4_do_setattr(inode, cred, fattr, sattr, state, NULL, label);
> if (status == 0)
> nfs_setattr_update_inode(inode, sattr);
> +
> + nfs4_label_free(label);
> return status;
> }
>
> @@ -2794,11 +2831,21 @@ static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry
> if (res.fattr == NULL)
> return -ENOMEM;
>
> + res.label = nfs4_label_alloc(server, GFP_KERNEL);
> + if (IS_ERR(res.label)) {
> + status = PTR_ERR(res.label);
> + goto out;
> + }
> +
> status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
> if (!status) {
> nfs_access_set_mask(entry, res.access);
> nfs_refresh_inode(inode, res.fattr, res.label);
> }
> +
> + nfs4_label_free(res.label);
> +
> +out:
> nfs_free_fattr(res.fattr);
> return status;
> }
> @@ -2922,6 +2969,7 @@ static int _nfs4_proc_remove(struct inode *dir, struct qstr *name)
> status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1);
> if (status == 0)
> update_changeattr(dir, &res.cinfo);
> +
> return status;
> }
>
> @@ -2965,6 +3013,7 @@ static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir)
> if (nfs4_async_handle_error(task, res->server, NULL) == -EAGAIN)
> return 0;
> update_changeattr(dir, &res->cinfo);
> +
> return 1;
> }
>
How'd these two hunks end up in here?
--b.
> @@ -3023,12 +3072,33 @@ static int _nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,
> .rpc_resp = &res,
> };
> int status = -ENOMEM;
> +
> +
> + if (server->caps & NFS_CAP_SECURITY_LABEL) {
> + res.old_label = nfs4_label_alloc(server, GFP_NOWAIT);
> + if (IS_ERR(res.old_label)) {
> + status = PTR_ERR(res.old_label);
> + goto out;
> + }
> + res.new_label = nfs4_label_alloc(server, GFP_NOWAIT);
> + if (IS_ERR(res.new_label)) {
> + status = PTR_ERR(res.new_label);
> + nfs4_label_free(res.old_label);
> + goto out;
> + }
> + }
> +
>
> status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
> if (!status) {
> update_changeattr(old_dir, &res.old_cinfo);
> update_changeattr(new_dir, &res.new_cinfo);
> }
> +
> + nfs4_label_free(res.old_label);
> + nfs4_label_free(res.new_label);
> +
> +out:
> return status;
> }
>
> @@ -3070,11 +3140,21 @@ static int _nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *
> if (res.fattr == NULL)
> goto out;
>
> + res.label = nfs4_label_alloc(server, GFP_KERNEL);
> + if (IS_ERR(res.label)) {
> + status = PTR_ERR(res.label);
> + goto out;
> + }
> +
> status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
> if (!status) {
> update_changeattr(dir, &res.cinfo);
> nfs_post_op_update_inode(inode, res.fattr, res.label);
> }
> +
> +
> + nfs4_label_free(res.label);
> +
> out:
> nfs_free_fattr(res.fattr);
> return status;
> @@ -3110,6 +3190,10 @@ static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,
> if (data != NULL) {
> struct nfs_server *server = NFS_SERVER(dir);
>
> + data->label = nfs4_label_alloc(server, GFP_KERNEL);
> + if (IS_ERR(data->label))
> + goto out_free;
> +
> data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE];
> data->msg.rpc_argp = &data->arg;
> data->msg.rpc_resp = &data->res;
> @@ -3126,6 +3210,9 @@ static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,
> nfs_fattr_init(data->res.fattr);
> }
> return data;
> +out_free:
> + kfree(data);
> + return NULL;
> }
>
> static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data)
> @@ -3141,6 +3228,7 @@ static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_
>
> static void nfs4_free_createdata(struct nfs4_createdata *data)
> {
> + nfs4_label_free(data->label);
> kfree(data);
> }
>
> --
> 1.7.11.7
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 06/15] NFSv4: Introduce new label structure
2013-02-12 22:07 ` J. Bruce Fields
@ 2013-02-12 22:28 ` Myklebust, Trond
0 siblings, 0 replies; 58+ messages in thread
From: Myklebust, Trond @ 2013-02-12 22:28 UTC (permalink / raw)
To: J. Bruce Fields
Cc: Steve Dickson, J. Bruce Fields, David P. Quigley, Linux NFS list,
Linux FS devel list, Linux Security List, SELinux List
On Tue, 2013-02-12 at 17:07 -0500, J. Bruce Fields wrote:
> On Fri, Feb 08, 2013 at 07:39:14AM -0500, Steve Dickson wrote:
> > From: David Quigley <dpquigl-a7DkhOHRHBuN9aS15agKxg@public.gmane.org>
> >
> > In order to mimic the way that NFSv4 ACLs are implemented we have created a
> > structure to be used to pass label data up and down the call chain. This patch
> > adds the new structure and new members to the required NFSv4 call structures.
> >
> > Signed-off-by: Matthew N. Dodd <Matthew.Dodd-DABiIiYg7OfQT0dZR+AlfA@public.gmane.org>
> > Signed-off-by: Miguel Rodel Felipe <Rodel_FM-geVtEqcQUv4Eyxwt80+Gtti2O/JbrIOy@public.gmane.org>
> > Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene-geVtEqcQUv4Eyxwt80+Gtti2O/JbrIOy@public.gmane.org>
> > Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG-geVtEqcQUv4Eyxwt80+Gtti2O/JbrIOy@public.gmane.org>
> > ---
> > fs/nfs/inode.c | 33 +++++++++++++++++++++++++++++++++
> > include/linux/nfs4.h | 7 +++++++
> > include/linux/nfs_fs.h | 17 +++++++++++++++++
> > include/linux/nfs_xdr.h | 21 +++++++++++++++++++++
> > include/uapi/linux/nfs4.h | 2 +-
> > 5 files changed, 79 insertions(+), 1 deletion(-)
> >
> > diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
> > index ebeb94c..8d5f01b 100644
> > --- a/fs/nfs/inode.c
> > +++ b/fs/nfs/inode.c
> > @@ -255,6 +255,39 @@ nfs_init_locked(struct inode *inode, void *opaque)
> > return 0;
> > }
> >
> > +#ifdef CONFIG_NFS_V4_SECURITY_LABEL
> > +struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags)
> > +{
> > + struct nfs4_label *label = NULL;
> > +
> > + if (!(server->caps & NFS_CAP_SECURITY_LABEL))
> > + return label;
> > +
> > + label = kzalloc(NFS4_MAXLABELLEN, flags);
> > + if (label == NULL)
> > + return ERR_PTR(-ENOMEM);
> > +
> > + label->label = (char *)(label + 1);
> > + label->len = NFS4_MAXLABELLEN;
>
> If you're expecting to be able to store up to NFS4_MAXLABELLEN of data
> after the end of the struct, then you want:
>
> label = kzalloc(sizeof(struct nfs4_label) + NFS4_MAXLABELLEN, flags);
Sigh... No.
I keep telling Steve that the 'label' needs to be defined as an array,
not a pointer. Having it be a pointer gives rise to a completely
unnecessary extra indirection (the CPU first needs to look up the
content of 'label->label', then dereference that pointer)...
IOW: we should just be defining struct nfs4_label as
struct nfs4_label {
.... lots of definitions ...
char label[NFS4_MAXLABELLEN];
};
in which case the above allocation becomes a trivial
label = kzalloc(sizeof(*label), flags);
> > +
> > + return label;
> > +}
> > +EXPORT_SYMBOL_GPL(nfs4_label_alloc);
> > +
> > +void nfs4_label_init(struct nfs4_label *label)
> > +{
> > + if (label && label->label) {
> > + /* 0 is the null format meaning that the data is not
> > + to be translated */
> > + label->lfs = 0;
> > + label->pi = 0;
> > + label->len = NFS4_MAXLABELLEN;
>
> This logic seems a little odd to me; why would we pass NULL to this?
> Why would we skip the other initialization in the !label->label case?
> Why is NFS4_MAXLABELLEN the default? (And wasn't that just set in
> nfs4_label_alloc?)
>
> But OK maybe I need to read the rest of the patches.
>
> > + }
> > + return;
> > +}
> > +EXPORT_SYMBOL_GPL(nfs4_label_init);
> > +#endif
>
> > diff --git a/include/uapi/linux/nfs4.h b/include/uapi/linux/nfs4.h
> > index 788128e..b8014a2 100644
> > --- a/include/uapi/linux/nfs4.h
> > +++ b/include/uapi/linux/nfs4.h
> > @@ -25,7 +25,7 @@
> > #define NFS4_MAXNAMLEN NAME_MAX
> > #define NFS4_OPAQUE_LIMIT 1024
> > #define NFS4_MAX_SESSIONID_LEN 16
> > -
> > +#define NFS4_MAXLABELLEN (4095 - offsetof(struct nfs4_label , label))
>
> The way you've defined things, that should be just
>
> (4095 - sizeof(struct nfs4_label))
No. See above. If the 'label' field is an array, then the offsetof() is
100% correct.
> (Is there typically some more alloc overhead that would push this
> allocation over 4k? I don't know well enough how the allocator(s) work
> to answer that.)
>
> --b.
>
> > #define NFS4_ACCESS_READ 0x0001
> > #define NFS4_ACCESS_LOOKUP 0x0002
> > #define NFS4_ACCESS_MODIFY 0x0004
--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 06/15] NFSv4: Introduce new label structure
@ 2013-02-12 22:28 ` Myklebust, Trond
0 siblings, 0 replies; 58+ messages in thread
From: Myklebust, Trond @ 2013-02-12 22:28 UTC (permalink / raw)
To: J. Bruce Fields
Cc: Steve Dickson, J. Bruce Fields, David P. Quigley, Linux NFS list,
Linux FS devel list, Linux Security List, SELinux List
On Tue, 2013-02-12 at 17:07 -0500, J. Bruce Fields wrote:
> On Fri, Feb 08, 2013 at 07:39:14AM -0500, Steve Dickson wrote:
> > From: David Quigley <dpquigl@davequigley.com>
> >
> > In order to mimic the way that NFSv4 ACLs are implemented we have created a
> > structure to be used to pass label data up and down the call chain. This patch
> > adds the new structure and new members to the required NFSv4 call structures.
> >
> > Signed-off-by: Matthew N. Dodd <Matthew.Dodd@sparta.com>
> > Signed-off-by: Miguel Rodel Felipe <Rodel_FM@dsi.a-star.edu.sg>
> > Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene@dsi.a-star.edu.sg>
> > Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG@dsi.a-star.edu.sg>
> > ---
> > fs/nfs/inode.c | 33 +++++++++++++++++++++++++++++++++
> > include/linux/nfs4.h | 7 +++++++
> > include/linux/nfs_fs.h | 17 +++++++++++++++++
> > include/linux/nfs_xdr.h | 21 +++++++++++++++++++++
> > include/uapi/linux/nfs4.h | 2 +-
> > 5 files changed, 79 insertions(+), 1 deletion(-)
> >
> > diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
> > index ebeb94c..8d5f01b 100644
> > --- a/fs/nfs/inode.c
> > +++ b/fs/nfs/inode.c
> > @@ -255,6 +255,39 @@ nfs_init_locked(struct inode *inode, void *opaque)
> > return 0;
> > }
> >
> > +#ifdef CONFIG_NFS_V4_SECURITY_LABEL
> > +struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags)
> > +{
> > + struct nfs4_label *label = NULL;
> > +
> > + if (!(server->caps & NFS_CAP_SECURITY_LABEL))
> > + return label;
> > +
> > + label = kzalloc(NFS4_MAXLABELLEN, flags);
> > + if (label == NULL)
> > + return ERR_PTR(-ENOMEM);
> > +
> > + label->label = (char *)(label + 1);
> > + label->len = NFS4_MAXLABELLEN;
>
> If you're expecting to be able to store up to NFS4_MAXLABELLEN of data
> after the end of the struct, then you want:
>
> label = kzalloc(sizeof(struct nfs4_label) + NFS4_MAXLABELLEN, flags);
Sigh... No.
I keep telling Steve that the 'label' needs to be defined as an array,
not a pointer. Having it be a pointer gives rise to a completely
unnecessary extra indirection (the CPU first needs to look up the
content of 'label->label', then dereference that pointer)...
IOW: we should just be defining struct nfs4_label as
struct nfs4_label {
.... lots of definitions ...
char label[NFS4_MAXLABELLEN];
};
in which case the above allocation becomes a trivial
label = kzalloc(sizeof(*label), flags);
> > +
> > + return label;
> > +}
> > +EXPORT_SYMBOL_GPL(nfs4_label_alloc);
> > +
> > +void nfs4_label_init(struct nfs4_label *label)
> > +{
> > + if (label && label->label) {
> > + /* 0 is the null format meaning that the data is not
> > + to be translated */
> > + label->lfs = 0;
> > + label->pi = 0;
> > + label->len = NFS4_MAXLABELLEN;
>
> This logic seems a little odd to me; why would we pass NULL to this?
> Why would we skip the other initialization in the !label->label case?
> Why is NFS4_MAXLABELLEN the default? (And wasn't that just set in
> nfs4_label_alloc?)
>
> But OK maybe I need to read the rest of the patches.
>
> > + }
> > + return;
> > +}
> > +EXPORT_SYMBOL_GPL(nfs4_label_init);
> > +#endif
>
> > diff --git a/include/uapi/linux/nfs4.h b/include/uapi/linux/nfs4.h
> > index 788128e..b8014a2 100644
> > --- a/include/uapi/linux/nfs4.h
> > +++ b/include/uapi/linux/nfs4.h
> > @@ -25,7 +25,7 @@
> > #define NFS4_MAXNAMLEN NAME_MAX
> > #define NFS4_OPAQUE_LIMIT 1024
> > #define NFS4_MAX_SESSIONID_LEN 16
> > -
> > +#define NFS4_MAXLABELLEN (4095 - offsetof(struct nfs4_label , label))
>
> The way you've defined things, that should be just
>
> (4095 - sizeof(struct nfs4_label))
No. See above. If the 'label' field is an array, then the offsetof() is
100% correct.
> (Is there typically some more alloc overhead that would push this
> allocation over 4k? I don't know well enough how the allocator(s) work
> to answer that.)
>
> --b.
>
> > #define NFS4_ACCESS_READ 0x0001
> > #define NFS4_ACCESS_LOOKUP 0x0002
> > #define NFS4_ACCESS_MODIFY 0x0004
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 06/15] NFSv4: Introduce new label structure
2013-02-12 22:28 ` Myklebust, Trond
(?)
@ 2013-02-12 22:32 ` J. Bruce Fields
2013-02-12 22:40 ` Myklebust, Trond
-1 siblings, 1 reply; 58+ messages in thread
From: J. Bruce Fields @ 2013-02-12 22:32 UTC (permalink / raw)
To: Myklebust, Trond
Cc: Steve Dickson, J. Bruce Fields, David P. Quigley, Linux NFS list,
Linux FS devel list, Linux Security List, SELinux List
On Tue, Feb 12, 2013 at 10:28:16PM +0000, Myklebust, Trond wrote:
> On Tue, 2013-02-12 at 17:07 -0500, J. Bruce Fields wrote:
> > On Fri, Feb 08, 2013 at 07:39:14AM -0500, Steve Dickson wrote:
> > > From: David Quigley <dpquigl@davequigley.com>
> > >
> > > In order to mimic the way that NFSv4 ACLs are implemented we have created a
> > > structure to be used to pass label data up and down the call chain. This patch
> > > adds the new structure and new members to the required NFSv4 call structures.
> > >
> > > Signed-off-by: Matthew N. Dodd <Matthew.Dodd@sparta.com>
> > > Signed-off-by: Miguel Rodel Felipe <Rodel_FM@dsi.a-star.edu.sg>
> > > Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene@dsi.a-star.edu.sg>
> > > Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG@dsi.a-star.edu.sg>
> > > ---
> > > fs/nfs/inode.c | 33 +++++++++++++++++++++++++++++++++
> > > include/linux/nfs4.h | 7 +++++++
> > > include/linux/nfs_fs.h | 17 +++++++++++++++++
> > > include/linux/nfs_xdr.h | 21 +++++++++++++++++++++
> > > include/uapi/linux/nfs4.h | 2 +-
> > > 5 files changed, 79 insertions(+), 1 deletion(-)
> > >
> > > diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
> > > index ebeb94c..8d5f01b 100644
> > > --- a/fs/nfs/inode.c
> > > +++ b/fs/nfs/inode.c
> > > @@ -255,6 +255,39 @@ nfs_init_locked(struct inode *inode, void *opaque)
> > > return 0;
> > > }
> > >
> > > +#ifdef CONFIG_NFS_V4_SECURITY_LABEL
> > > +struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags)
> > > +{
> > > + struct nfs4_label *label = NULL;
> > > +
> > > + if (!(server->caps & NFS_CAP_SECURITY_LABEL))
> > > + return label;
> > > +
> > > + label = kzalloc(NFS4_MAXLABELLEN, flags);
> > > + if (label == NULL)
> > > + return ERR_PTR(-ENOMEM);
> > > +
> > > + label->label = (char *)(label + 1);
> > > + label->len = NFS4_MAXLABELLEN;
> >
> > If you're expecting to be able to store up to NFS4_MAXLABELLEN of data
> > after the end of the struct, then you want:
> >
> > label = kzalloc(sizeof(struct nfs4_label) + NFS4_MAXLABELLEN, flags);
>
> Sigh... No.
>
> I keep telling Steve that the 'label' needs to be defined as an array,
Yeah, I know, he said in 0/15 that he couldn't do that, so I've been
reading through these on the assumption I'll find out why not at some
point.... (Still not seeing it, though.)
--b.
> not a pointer. Having it be a pointer gives rise to a completely
> unnecessary extra indirection (the CPU first needs to look up the
> content of 'label->label', then dereference that pointer)...
>
> IOW: we should just be defining struct nfs4_label as
>
> struct nfs4_label {
>
> .... lots of definitions ...
>
> char label[NFS4_MAXLABELLEN];
> };
>
> in which case the above allocation becomes a trivial
>
> label = kzalloc(sizeof(*label), flags);
>
>
>
> > > +
> > > + return label;
> > > +}
> > > +EXPORT_SYMBOL_GPL(nfs4_label_alloc);
> > > +
> > > +void nfs4_label_init(struct nfs4_label *label)
> > > +{
> > > + if (label && label->label) {
> > > + /* 0 is the null format meaning that the data is not
> > > + to be translated */
> > > + label->lfs = 0;
> > > + label->pi = 0;
> > > + label->len = NFS4_MAXLABELLEN;
> >
> > This logic seems a little odd to me; why would we pass NULL to this?
> > Why would we skip the other initialization in the !label->label case?
> > Why is NFS4_MAXLABELLEN the default? (And wasn't that just set in
> > nfs4_label_alloc?)
> >
> > But OK maybe I need to read the rest of the patches.
> >
> > > + }
> > > + return;
> > > +}
> > > +EXPORT_SYMBOL_GPL(nfs4_label_init);
> > > +#endif
> >
> > > diff --git a/include/uapi/linux/nfs4.h b/include/uapi/linux/nfs4.h
> > > index 788128e..b8014a2 100644
> > > --- a/include/uapi/linux/nfs4.h
> > > +++ b/include/uapi/linux/nfs4.h
> > > @@ -25,7 +25,7 @@
> > > #define NFS4_MAXNAMLEN NAME_MAX
> > > #define NFS4_OPAQUE_LIMIT 1024
> > > #define NFS4_MAX_SESSIONID_LEN 16
> > > -
> > > +#define NFS4_MAXLABELLEN (4095 - offsetof(struct nfs4_label , label))
> >
> > The way you've defined things, that should be just
> >
> > (4095 - sizeof(struct nfs4_label))
>
> No. See above. If the 'label' field is an array, then the offsetof() is
> 100% correct.
>
> > (Is there typically some more alloc overhead that would push this
> > allocation over 4k? I don't know well enough how the allocator(s) work
> > to answer that.)
> >
> > --b.
> >
> > > #define NFS4_ACCESS_READ 0x0001
> > > #define NFS4_ACCESS_LOOKUP 0x0002
> > > #define NFS4_ACCESS_MODIFY 0x0004
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 06/15] NFSv4: Introduce new label structure
2013-02-12 22:32 ` J. Bruce Fields
@ 2013-02-12 22:40 ` Myklebust, Trond
2013-02-12 23:06 ` J. Bruce Fields
0 siblings, 1 reply; 58+ messages in thread
From: Myklebust, Trond @ 2013-02-12 22:40 UTC (permalink / raw)
To: J. Bruce Fields
Cc: Steve Dickson, J. Bruce Fields, David P. Quigley, Linux NFS list,
Linux FS devel list, Linux Security List, SELinux List
On Tue, 2013-02-12 at 17:32 -0500, J. Bruce Fields wrote:
> On Tue, Feb 12, 2013 at 10:28:16PM +0000, Myklebust, Trond wrote:
> > On Tue, 2013-02-12 at 17:07 -0500, J. Bruce Fields wrote:
> > > On Fri, Feb 08, 2013 at 07:39:14AM -0500, Steve Dickson wrote:
> > > > From: David Quigley <dpquigl@davequigley.com>
> > > >
> > > > In order to mimic the way that NFSv4 ACLs are implemented we have created a
> > > > structure to be used to pass label data up and down the call chain. This patch
> > > > adds the new structure and new members to the required NFSv4 call structures.
> > > >
> > > > Signed-off-by: Matthew N. Dodd <Matthew.Dodd@sparta.com>
> > > > Signed-off-by: Miguel Rodel Felipe <Rodel_FM@dsi.a-star.edu.sg>
> > > > Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene@dsi.a-star.edu.sg>
> > > > Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG@dsi.a-star.edu.sg>
> > > > ---
> > > > fs/nfs/inode.c | 33 +++++++++++++++++++++++++++++++++
> > > > include/linux/nfs4.h | 7 +++++++
> > > > include/linux/nfs_fs.h | 17 +++++++++++++++++
> > > > include/linux/nfs_xdr.h | 21 +++++++++++++++++++++
> > > > include/uapi/linux/nfs4.h | 2 +-
> > > > 5 files changed, 79 insertions(+), 1 deletion(-)
> > > >
> > > > diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
> > > > index ebeb94c..8d5f01b 100644
> > > > --- a/fs/nfs/inode.c
> > > > +++ b/fs/nfs/inode.c
> > > > @@ -255,6 +255,39 @@ nfs_init_locked(struct inode *inode, void *opaque)
> > > > return 0;
> > > > }
> > > >
> > > > +#ifdef CONFIG_NFS_V4_SECURITY_LABEL
> > > > +struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags)
> > > > +{
> > > > + struct nfs4_label *label = NULL;
> > > > +
> > > > + if (!(server->caps & NFS_CAP_SECURITY_LABEL))
> > > > + return label;
> > > > +
> > > > + label = kzalloc(NFS4_MAXLABELLEN, flags);
> > > > + if (label == NULL)
> > > > + return ERR_PTR(-ENOMEM);
> > > > +
> > > > + label->label = (char *)(label + 1);
> > > > + label->len = NFS4_MAXLABELLEN;
> > >
> > > If you're expecting to be able to store up to NFS4_MAXLABELLEN of data
> > > after the end of the struct, then you want:
> > >
> > > label = kzalloc(sizeof(struct nfs4_label) + NFS4_MAXLABELLEN, flags);
> >
> > Sigh... No.
> >
> > I keep telling Steve that the 'label' needs to be defined as an array,
>
> Yeah, I know, he said in 0/15 that he couldn't do that, so I've been
> reading through these on the assumption I'll find out why not at some
> point.... (Still not seeing it, though.)
It only makes sense to define label->label as a pointer if you need to
change the pointer value at some time. However, if that is the case,
then why allocate the struct nfs4_label and label string as a single
memory block? It would make more sense to allocate them separately so
that you can free the old label storage after you change the pointer.
Trond
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 14/15] NFSD: Server implementation of MAC Labeling
2013-02-08 12:39 ` [PATCH 14/15] NFSD: Server implementation of MAC Labeling Steve Dickson
@ 2013-02-12 22:54 ` J. Bruce Fields
2013-02-12 23:07 ` J. Bruce Fields
[not found] ` <20130212225425.GM10267-uC3wQj2KruNg9hUCZPvPmw@public.gmane.org>
0 siblings, 2 replies; 58+ messages in thread
From: J. Bruce Fields @ 2013-02-12 22:54 UTC (permalink / raw)
To: Steve Dickson
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On Fri, Feb 08, 2013 at 07:39:22AM -0500, Steve Dickson wrote:
> From: David Quigley <dpquigl@davequigley.com>
>
> This patch adds the ability to encode and decode file labels on the server for
> the purpose of sending them to the client and also to process label change
> requests from the client.
>
> Signed-off-by: Matthew N. Dodd <Matthew.Dodd@sparta.com>
> Signed-off-by: Miguel Rodel Felipe <Rodel_FM@dsi.a-star.edu.sg>
> Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene@dsi.a-star.edu.sg>
> Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG@dsi.a-star.edu.sg>
> ---
> fs/nfsd/nfs4proc.c | 41 +++++++++++++++++++
> fs/nfsd/nfs4xdr.c | 116 ++++++++++++++++++++++++++++++++++++++++++++++++++---
> fs/nfsd/nfsd.h | 8 ++--
> fs/nfsd/vfs.c | 30 ++++++++++++++
> fs/nfsd/vfs.h | 2 +
> fs/nfsd/xdr4.h | 3 ++
> 6 files changed, 191 insertions(+), 9 deletions(-)
>
> diff --git a/fs/nfsd/nfs4proc.c b/fs/nfsd/nfs4proc.c
> index 9d1c5db..898092d 100644
> --- a/fs/nfsd/nfs4proc.c
> +++ b/fs/nfsd/nfs4proc.c
> @@ -42,6 +42,36 @@
> #include "current_stateid.h"
> #include "netns.h"
>
> +#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
> +#include <linux/security.h>
> +
> +static inline void
> +nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct nfs4_label *label, u32 *bmval)
> +{
> + struct inode *inode = resfh->fh_dentry->d_inode;
> + int status;
> +
> + mutex_lock(&inode->i_mutex);
> + status = security_inode_setsecctx(resfh->fh_dentry,
> + label->label, label->len);
> + mutex_unlock(&inode->i_mutex);
> +
> + if (status)
> + /*
> + * We should probably fail the whole open at this point,
> + * but we've already created or opened the file, so it's
> + * too late; So this seems the least of evils:
> + */
> + bmval[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
> +
> + return;
> +}
> +#else
> +static inline void
> +nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct nfs4_label *label, u32 *bmval)
> +{ }
> +#endif
> +
> #define NFSDDBG_FACILITY NFSDDBG_PROC
>
> static u32 nfsd_attrmask[] = {
> @@ -230,6 +260,9 @@ do_open_lookup(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_o
> (u32 *)open->op_verf.data,
> &open->op_truncate, &open->op_created);
>
> + if (!status && open->op_label != NULL)
> + nfsd4_security_inode_setsecctx(resfh, open->op_label, open->op_bmval);
> +
> /*
> * Following rfc 3530 14.2.16, use the returned bitmask
> * to indicate which attributes we used to store the
> @@ -599,6 +632,9 @@ nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
> if (status)
> goto out;
>
> + if (create->cr_label != NULL)
> + nfsd4_security_inode_setsecctx(&resfh, create->cr_label, create->cr_bmval);
> +
> if (create->cr_acl != NULL)
> do_set_nfs4_acl(rqstp, &resfh, create->cr_acl,
> create->cr_bmval);
> @@ -888,6 +924,11 @@ nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
> setattr->sa_acl);
> if (status)
> goto out;
> + if (setattr->sa_label != NULL)
> + status = nfsd4_set_nfs4_label(rqstp, &cstate->current_fh,
> + setattr->sa_label);
> + if (status)
> + goto out;
> status = nfsd_setattr(rqstp, &cstate->current_fh, &setattr->sa_iattr,
> 0, (time_t)0);
> out:
> diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
> index 0dc1158..0124b43 100644
> --- a/fs/nfsd/nfs4xdr.c
> +++ b/fs/nfsd/nfs4xdr.c
> @@ -55,6 +55,11 @@
> #include "cache.h"
> #include "netns.h"
>
> +#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
> +#include <linux/security.h>
> +#endif
> +
> +
> #define NFSDDBG_FACILITY NFSDDBG_XDR
>
> /*
> @@ -242,7 +247,8 @@ nfsd4_decode_bitmap(struct nfsd4_compoundargs *argp, u32 *bmval)
>
> static __be32
> nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval,
> - struct iattr *iattr, struct nfs4_acl **acl)
> + struct iattr *iattr, struct nfs4_acl **acl,
> + struct nfs4_label **label)
> {
> int expected_len, len = 0;
> u32 dummy32;
> @@ -386,6 +392,50 @@ nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval,
> goto xdr_error;
> }
> }
> +#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
> + if (bmval[2] & FATTR4_WORD2_SECURITY_LABEL) {
> + uint32_t pi;
> + uint32_t lfs;
> +
> + READ_BUF(4);
> + len += 4;
> + READ32(lfs);
> + READ_BUF(4);
> + len += 4;
> + READ32(pi);
> + READ_BUF(4);
> + len += 4;
> + READ32(dummy32);
> + READ_BUF(dummy32);
> + len += (XDR_QUADLEN(dummy32) << 2);
> + READMEM(buf, dummy32);
> +
> + if (dummy32 > NFS4_MAXLABELLEN)
> + return nfserr_resource;
> +
> + *label = kzalloc(sizeof(struct nfs4_label), GFP_KERNEL);
So we don't want to allocate these the same way we did on the client?
> + if (*label == NULL) {
> + host_err = -ENOMEM;
> + goto out_nfserr;
> + }
> +
> + (*label)->label = kmalloc(dummy32 + 1, GFP_KERNEL);
> + if ((*label)->label == NULL) {
> + host_err = -ENOMEM;
> + kfree(*label);
> + goto out_nfserr;
> + }
> +
> + (*label)->len = dummy32;
> + memcpy((*label)->label, buf, dummy32);
> + ((char *)(*label)->label)[dummy32] = '\0';
> + (*label)->pi = pi;
> + (*label)->lfs = lfs;
> +
> + defer_free(argp, kfree, (*label)->label);
> + defer_free(argp, kfree, *label);
Hm: looking at defer_free and nfsd4_release_compoundargs: looks like
argp->to_free is effectively a stack, so these will get freed in the
reverse order: *label first, then (*label)->label. That's trouble.
So, I think we want the order of those two defer_free()'s reversed.
Or we could just allocate the whole things as one chunk as on the client
and not have to worry about this kind of thing. I think I'd prefer that
to trying to keep the allocation as small as possible. We're only using
this memory temporarily so it's not as though we need to have tons of
struct nfs4_labels allocated at the same time anyway.
> + }
> +#endif
> if (bmval[0] & ~NFSD_WRITEABLE_ATTRS_WORD0
> || bmval[1] & ~NFSD_WRITEABLE_ATTRS_WORD1
> || bmval[2] & ~NFSD_WRITEABLE_ATTRS_WORD2)
> @@ -575,7 +625,7 @@ nfsd4_decode_create(struct nfsd4_compoundargs *argp, struct nfsd4_create *create
> return status;
>
> status = nfsd4_decode_fattr(argp, create->cr_bmval, &create->cr_iattr,
> - &create->cr_acl);
> + &create->cr_acl, &create->cr_label);
> if (status)
> goto out;
>
> @@ -825,7 +875,7 @@ nfsd4_decode_open(struct nfsd4_compoundargs *argp, struct nfsd4_open *open)
> case NFS4_CREATE_UNCHECKED:
> case NFS4_CREATE_GUARDED:
> status = nfsd4_decode_fattr(argp, open->op_bmval,
> - &open->op_iattr, &open->op_acl);
> + &open->op_iattr, &open->op_acl, &open->op_label);
> if (status)
> goto out;
> break;
> @@ -839,7 +889,7 @@ nfsd4_decode_open(struct nfsd4_compoundargs *argp, struct nfsd4_open *open)
> READ_BUF(NFS4_VERIFIER_SIZE);
> COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE);
> status = nfsd4_decode_fattr(argp, open->op_bmval,
> - &open->op_iattr, &open->op_acl);
> + &open->op_iattr, &open->op_acl, &open->op_label);
> if (status)
> goto out;
> break;
> @@ -1061,7 +1111,7 @@ nfsd4_decode_setattr(struct nfsd4_compoundargs *argp, struct nfsd4_setattr *seta
> if (status)
> return status;
> return nfsd4_decode_fattr(argp, setattr->sa_bmval, &setattr->sa_iattr,
> - &setattr->sa_acl);
> + &setattr->sa_acl, &setattr->sa_label);
> }
>
> static __be32
> @@ -1970,6 +2020,50 @@ nfsd4_encode_aclname(struct svc_rqst *rqstp, int whotype, uid_t id, int group,
> FATTR4_WORD0_RDATTR_ERROR)
> #define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID
>
> +#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
> +static inline __be32
> +nfsd4_encode_security_label(struct svc_rqst *rqstp, struct dentry *dentry, __be32 **pp, int *buflen)
> +{
> + void *context;
> + int err;
> + int len;
> + uint32_t pi = 0;
> + uint32_t lfs = 0;
> + __be32 *p = *pp;
> +
> + err = 0;
> + (void)security_inode_getsecctx(dentry->d_inode, &context, &len);
> + if (len < 0)
> + return nfserrno(len);
> +
> + if (*buflen < ((XDR_QUADLEN(len) << 2) + 4 + 4 + 4)) {
> + err = nfserr_resource;
> + goto out;
> + }
> +
> + /* XXX: A call to the translation code should be placed here
> + * for now send 0 until we have that to indicate the null
> + * translation */
> +
> + if ((*buflen -= 4) < 0)
> + return nfserr_resource;
> +
> + WRITE32(lfs);
> + WRITE32(pi);
> + p = xdr_encode_opaque(p, context, len);
> + *buflen -= (XDR_QUADLEN(len) << 2) + 4;
> +
> + *pp = p;
> +out:
> + security_release_secctx(context, len);
> + return err;
> +}
> +#else
> +static inline __be32
> +nfsd4_encode_security_label(struct svc_rqst *rqstp, struct dentry *dentry, __be32 **pp, int *buflen)
> +{ return 0; }
> +#endif
> +
> static __be32 fattr_handle_absent_fs(u32 *bmval0, u32 *bmval1, u32 *rdattr_err)
> {
> /* As per referral draft: */
> @@ -2111,6 +2205,10 @@ nfsd4_encode_fattr(struct svc_fh *fhp, struct svc_export *exp,
>
> if (!aclsupport)
> word0 &= ~FATTR4_WORD0_ACL;
> +#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
> + if (word2)
> + word2 |= FATTR4_WORD2_SECURITY_LABEL;
> +#endif
Please just fix the definition of NFSD4_1_SUPPORTED_ATTRS_WORD2. (The
ifdef can go in that definition.)
Although: don't we need to check whether the exported filesystem
supports security labels?
> if (!word2) {
> if ((buflen -= 12) < 0)
> goto out_resource;
> @@ -2423,6 +2521,14 @@ out_acl:
> get_parent_attributes(exp, &stat);
> WRITE64(stat.ino);
> }
> + if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) {
> + status = nfsd4_encode_security_label(rqstp, dentry,
> + &p, &buflen);
> + if (status == nfserr_resource)
> + goto out_resource;
Just remove that, there's no real point to the out_resource goto.
> + if (status)
> + goto out;
> + }
> if (bmval2 & FATTR4_WORD2_SUPPATTR_EXCLCREAT) {
> WRITE32(3);
> WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD0);
> diff --git a/fs/nfsd/nfsd.h b/fs/nfsd/nfsd.h
> index de23db2..727fe44 100644
> --- a/fs/nfsd/nfsd.h
> +++ b/fs/nfsd/nfsd.h
> @@ -308,10 +308,10 @@ void nfsd_lockd_shutdown(void);
> | FATTR4_WORD1_OWNER | FATTR4_WORD1_OWNER_GROUP | FATTR4_WORD1_RAWDEV \
> | FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE | FATTR4_WORD1_SPACE_TOTAL \
> | FATTR4_WORD1_SPACE_USED | FATTR4_WORD1_TIME_ACCESS | FATTR4_WORD1_TIME_ACCESS_SET \
> - | FATTR4_WORD1_TIME_DELTA | FATTR4_WORD1_TIME_METADATA \
> - | FATTR4_WORD1_TIME_MODIFY | FATTR4_WORD1_TIME_MODIFY_SET | FATTR4_WORD1_MOUNTED_ON_FILEID)
> + | FATTR4_WORD1_TIME_DELTA | FATTR4_WORD1_TIME_METADATA | FATTR4_WORD1_TIME_MODIFY \
> + | FATTR4_WORD1_TIME_MODIFY_SET | FATTR4_WORD1_MOUNTED_ON_FILEID)
Did that actually change anything? If not, just leave the formatting
alone.
>
> -#define NFSD4_SUPPORTED_ATTRS_WORD2 0
> +#define NFSD4_SUPPORTED_ATTRS_WORD2 FATTR4_WORD2_SECURITY_LABEL
That should be conditional on CONFIG_NFSD_V4_SECURITY_LABEL, shouldn't
it?
>
> #define NFSD4_1_SUPPORTED_ATTRS_WORD0 \
> NFSD4_SUPPORTED_ATTRS_WORD0
> @@ -350,7 +350,7 @@ static inline u32 nfsd_suppattrs2(u32 minorversion)
> #define NFSD_WRITEABLE_ATTRS_WORD1 \
> (FATTR4_WORD1_MODE | FATTR4_WORD1_OWNER | FATTR4_WORD1_OWNER_GROUP \
> | FATTR4_WORD1_TIME_ACCESS_SET | FATTR4_WORD1_TIME_MODIFY_SET)
> -#define NFSD_WRITEABLE_ATTRS_WORD2 0
> +#define NFSD_WRITEABLE_ATTRS_WORD2 FATTR4_WORD2_SECURITY_LABEL
>
> #define NFSD_SUPPATTR_EXCLCREAT_WORD0 \
> NFSD_WRITEABLE_ATTRS_WORD0
> diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
> index d586117..0567fdc 100644
> --- a/fs/nfsd/vfs.c
> +++ b/fs/nfsd/vfs.c
> @@ -28,6 +28,7 @@
> #include <asm/uaccess.h>
> #include <linux/exportfs.h>
> #include <linux/writeback.h>
> +#include <linux/security.h>
>
> #ifdef CONFIG_NFSD_V3
> #include "xdr3.h"
> @@ -621,6 +622,35 @@ int nfsd4_is_junction(struct dentry *dentry)
> return 0;
> return 1;
> }
> +#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
> +__be32 nfsd4_set_nfs4_label(struct svc_rqst *rqstp, struct svc_fh *fhp,
> + struct nfs4_label *label)
> +{
> + __be32 error;
> + int host_error;
> + struct dentry *dentry;
> +
> + /* Get inode */
That comment's unnecessary.
> + /* XXX: should we have a MAY_SSECCTX? */
I don't know, should we?
--b.
> + error = fh_verify(rqstp, fhp, 0 /* S_IFREG */, NFSD_MAY_SATTR);
> + if (error)
> + return error;
> +
> + dentry = fhp->fh_dentry;
> +
> + mutex_lock(&dentry->d_inode->i_mutex);
> + host_error = security_inode_setsecctx(dentry, label->label, label->len);
> + mutex_unlock(&dentry->d_inode->i_mutex);
> + return nfserrno(host_error);
> +}
> +#else
> +__be32 nfsd4_set_nfs4_label(struct svc_rqst *rqstp, struct svc_fh *fhp,
> + struct nfs4_label *label)
> +{
> + return -EOPNOTSUPP;
> +}
> +#endif
> +
> #endif /* defined(CONFIG_NFSD_V4) */
>
> #ifdef CONFIG_NFSD_V3
> diff --git a/fs/nfsd/vfs.h b/fs/nfsd/vfs.h
> index 359594c..49c6cc0 100644
> --- a/fs/nfsd/vfs.h
> +++ b/fs/nfsd/vfs.h
> @@ -55,6 +55,8 @@ int nfsd_mountpoint(struct dentry *, struct svc_export *);
> __be32 nfsd4_set_nfs4_acl(struct svc_rqst *, struct svc_fh *,
> struct nfs4_acl *);
> int nfsd4_get_nfs4_acl(struct svc_rqst *, struct dentry *, struct nfs4_acl **);
> +__be32 nfsd4_set_nfs4_label(struct svc_rqst *, struct svc_fh *,
> + struct nfs4_label *);
> #endif /* CONFIG_NFSD_V4 */
> __be32 nfsd_create(struct svc_rqst *, struct svc_fh *,
> char *name, int len, struct iattr *attrs,
> diff --git a/fs/nfsd/xdr4.h b/fs/nfsd/xdr4.h
> index 0889bfb..9e7e663 100644
> --- a/fs/nfsd/xdr4.h
> +++ b/fs/nfsd/xdr4.h
> @@ -118,6 +118,7 @@ struct nfsd4_create {
> struct iattr cr_iattr; /* request */
> struct nfsd4_change_info cr_cinfo; /* response */
> struct nfs4_acl *cr_acl;
> + struct nfs4_label *cr_label;
> };
> #define cr_linklen u.link.namelen
> #define cr_linkname u.link.name
> @@ -246,6 +247,7 @@ struct nfsd4_open {
> struct nfs4_file *op_file; /* used during processing */
> struct nfs4_ol_stateid *op_stp; /* used during processing */
> struct nfs4_acl *op_acl;
> + struct nfs4_label *op_label;
> };
> #define op_iattr iattr
>
> @@ -330,6 +332,7 @@ struct nfsd4_setattr {
> u32 sa_bmval[3]; /* request */
> struct iattr sa_iattr; /* request */
> struct nfs4_acl *sa_acl;
> + struct nfs4_label *sa_label;
> };
>
> struct nfsd4_setclientid {
> --
> 1.7.11.7
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 10/15] NFS: Client implementation of Labeled-NFS
2013-02-08 12:39 ` Steve Dickson
(?)
@ 2013-02-12 23:03 ` J. Bruce Fields
2013-02-16 20:35 ` Steve Dickson
-1 siblings, 1 reply; 58+ messages in thread
From: J. Bruce Fields @ 2013-02-12 23:03 UTC (permalink / raw)
To: Steve Dickson
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On Fri, Feb 08, 2013 at 07:39:18AM -0500, Steve Dickson wrote:
> From: David Quigley <dpquigl@davequigley.com>
>
> This patch implements the client transport and handling support for labeled
> NFS. The patch adds two functions to encode and decode the security label
> recommended attribute which makes use of the LSM hooks added earlier. It also
> adds code to grab the label from the file attribute structures and encode the
> label to be sent back to the server.
>
> Signed-off-by: Matthew N. Dodd <Matthew.Dodd@sparta.com>
> Signed-off-by: Miguel Rodel Felipe <Rodel_FM@dsi.a-star.edu.sg>
> Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene@dsi.a-star.edu.sg>
> Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG@dsi.a-star.edu.sg>
> ---
> fs/nfs/inode.c | 55 ++++++++-
> fs/nfs/nfs4proc.c | 298 ++++++++++++++++++++++++++++++++++++++++++++--
> fs/nfs/nfs4xdr.c | 179 ++++++++++++++++++++++------
> fs/nfs/super.c | 17 ++-
> include/linux/nfs_fs.h | 3 +
> include/linux/nfs_fs_sb.h | 7 ++
> security/selinux/hooks.c | 4 +
> 7 files changed, 507 insertions(+), 56 deletions(-)
>
> diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
> index 0cb67cf..0d412c4 100644
> --- a/fs/nfs/inode.c
> +++ b/fs/nfs/inode.c
> @@ -162,11 +162,19 @@ static void nfs_zap_caches_locked(struct inode *inode)
>
> memset(NFS_I(inode)->cookieverf, 0, sizeof(NFS_I(inode)->cookieverf));
> if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) {
> - nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
> nfs_fscache_invalidate(inode);
> - } else {
> - nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
> - }
> + nfsi->cache_validity |= NFS_INO_INVALID_ATTR
> + | NFS_INO_INVALID_LABEL
> + | NFS_INO_INVALID_DATA
> + | NFS_INO_INVALID_ACCESS
> + | NFS_INO_INVALID_ACL
> + | NFS_INO_REVAL_PAGECACHE;
> + } else
> + nfsi->cache_validity |= NFS_INO_INVALID_ATTR
> + | NFS_INO_INVALID_LABEL
> + | NFS_INO_INVALID_ACCESS
> + | NFS_INO_INVALID_ACL
> + | NFS_INO_REVAL_PAGECACHE;
> }
>
> void nfs_zap_caches(struct inode *inode)
> @@ -256,6 +264,24 @@ nfs_init_locked(struct inode *inode, void *opaque)
> }
>
> #ifdef CONFIG_NFS_V4_SECURITY_LABEL
> +void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr,
> + struct nfs4_label *label)
> +{
> + int error;
> +
> + if ((fattr->valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL) &&
> + label && inode->i_security) {
> + error = security_inode_notifysecctx(inode, label->label,
> + label->len);
> + if (error)
> + printk(KERN_ERR "%s() %s %d "
> + "security_inode_notifysecctx() %d\n",
> + __func__,
> + (char *)label->label,
> + label->len, error);
> + }
> +}
> +
> struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags)
> {
> struct nfs4_label *label = NULL;
> @@ -286,7 +312,15 @@ void nfs4_label_init(struct nfs4_label *label)
> return;
> }
> EXPORT_SYMBOL_GPL(nfs4_label_init);
> +EXPORT_SYMBOL_GPL(nfs4_label_free);
> +
> +#else
> +void inline nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr,
> + struct nfs4_label *label)
> +{
> +}
> #endif
> +EXPORT_SYMBOL_GPL(nfs_setsecurity);
>
> /*
> * This is our front-end to iget that looks up inodes by file handle
> @@ -415,6 +449,9 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr, st
> */
> inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
> }
> +
> + nfs_setsecurity(inode, fattr, label);
> +
> nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
> nfsi->attrtimeo_timestamp = now;
> nfsi->access_cache = RB_ROOT;
> @@ -777,6 +814,7 @@ struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_c
> spin_unlock(&inode->i_lock);
> return ctx;
> }
> +EXPORT_SYMBOL_GPL(nfs_find_open_context);
>
> static void nfs_file_clear_open_context(struct file *filp)
> {
> @@ -905,7 +943,8 @@ static int nfs_attribute_cache_expired(struct inode *inode)
> */
> int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
> {
> - if (!(NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATTR)
> + if (!(NFS_I(inode)->cache_validity &
> + (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_LABEL))
> && !nfs_attribute_cache_expired(inode))
> return NFS_STALE(inode) ? -ESTALE : 0;
> return __nfs_revalidate_inode(server, inode);
> @@ -1504,6 +1543,9 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr, struct
> | NFS_INO_INVALID_ACL
> | NFS_INO_REVAL_FORCED);
>
> + if (label && (server->caps & NFS_CAP_SECURITY_LABEL))
> + nfs_setsecurity(inode, fattr, label);
> +
> if (fattr->valid & NFS_ATTR_FATTR_NLINK) {
> if (inode->i_nlink != fattr->nlink) {
> invalid |= NFS_INO_INVALID_ATTR;
> @@ -1525,7 +1567,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr, struct
> inode->i_blocks = fattr->du.nfs2.blocks;
>
> /* Update attrtimeo value if we're out of the unstable period */
> - if (invalid & NFS_INO_INVALID_ATTR) {
> + if (invalid & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_LABEL)) {
> nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
> nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
> nfsi->attrtimeo_timestamp = now;
> @@ -1538,6 +1580,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr, struct
> }
> }
> invalid &= ~NFS_INO_INVALID_ATTR;
> + invalid &= ~NFS_INO_INVALID_LABEL;
> /* Don't invalidate the data if we were to blame */
> if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
> || S_ISLNK(inode->i_mode)))
> diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
> index 5c9233d1..280bb22 100644
> --- a/fs/nfs/nfs4proc.c
> +++ b/fs/nfs/nfs4proc.c
> @@ -87,6 +87,39 @@ static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
> static int nfs41_test_stateid(struct nfs_server *, nfs4_stateid *);
> static int nfs41_free_stateid(struct nfs_server *, nfs4_stateid *);
> #endif
> +
> +#ifdef CONFIG_NFS_V4_SECURITY_LABEL
> +static inline struct nfs4_label *
> +nfs4_label_init_security(struct inode *dir, struct dentry *dentry,
> + struct iattr *sattr, struct nfs4_label *l)
> +{
> + int err;
> +
> + if (nfs_server_capable(dir, NFS_CAP_SECURITY_LABEL)) {
> + err = security_dentry_init_security(dentry, sattr->ia_mode,
> + &dentry->d_name, (void **)&l->label, &l->len);
> + if (err == 0)
> + return l;
> + }
> + return NULL;
> +}
> +static inline void
> +nfs4_label_release_security(struct nfs4_label *label)
> +{
> + if (label)
> + security_release_secctx(label->label, label->len);
> +}
> +#else
> +static inline struct nfs4_label *
> +nfs4_label_init_security(struct inode *dir, struct dentry *dentry,
> + struct iattr *sattr, struct nfs4_label *l)
> +{ return NULL; }
> +
> +static inline void
> +nfs4_label_release_security(struct nfs4_label *label)
> +{ return; }
> +#endif
> +
> /* Prevent leaks of NFSv4 errors into userland */
> static int nfs4_map_errors(int err)
> {
> @@ -131,7 +164,8 @@ const u32 nfs4_fattr_bitmap[3] = {
> | FATTR4_WORD1_SPACE_USED
> | FATTR4_WORD1_TIME_ACCESS
> | FATTR4_WORD1_TIME_METADATA
> - | FATTR4_WORD1_TIME_MODIFY
> + | FATTR4_WORD1_TIME_MODIFY,
> + FATTR4_WORD2_SECURITY_LABEL
> };
>
> static const u32 nfs4_pnfs_open_bitmap[3] = {
> @@ -1939,6 +1973,7 @@ static int _nfs4_do_open(struct inode *dir,
> if (status == 0) {
> nfs_setattr_update_inode(state->inode, sattr);
> nfs_post_op_update_inode(state->inode, opendata->o_res.f_attr, olabel);
> + nfs_setsecurity(state->inode, opendata->o_res.f_attr, olabel);
> }
> }
>
> @@ -2052,6 +2087,9 @@ static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
> unsigned long timestamp = jiffies;
> int status;
>
> + if (ilabel == NULL || olabel == NULL)
> + arg.bitmask = server->attr_bitmask_nl;
> +
> nfs_fattr_init(fattr);
>
> if (state != NULL) {
> @@ -2279,7 +2317,7 @@ int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait)
> if (calldata->arg.seqid == NULL)
> goto out_free_calldata;
> calldata->arg.fmode = 0;
> - calldata->arg.bitmask = server->cache_consistency_bitmask;
> + calldata->arg.bitmask = server->cache_consistency_bitmask_nl;
> calldata->res.fattr = &calldata->fattr;
> calldata->res.seqid = calldata->arg.seqid;
> calldata->res.server = server;
> @@ -2309,11 +2347,16 @@ static struct inode *
> nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx, int open_flags, struct iattr *attr)
> {
> struct nfs4_state *state;
> - struct nfs4_label *label = NULL;
> + struct nfs4_label l, *label = NULL;
> +
> + label = nfs4_label_init_security(dir, ctx->dentry, attr, &l);
>
> /* Protect against concurrent sillydeletes */
> state = nfs4_do_open(dir, ctx->dentry, ctx->mode, open_flags, attr, label,
> ctx->cred, &ctx->mdsthreshold);
> +
> + nfs4_label_release_security(label);
> +
> if (IS_ERR(state))
> return ERR_CAST(state);
> ctx->state = state;
> @@ -2373,10 +2416,27 @@ static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *f
> server->caps |= NFS_CAP_CTIME;
> if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY)
> server->caps |= NFS_CAP_MTIME;
> +#ifdef CONFIG_NFS_V4_SECURITY_LABEL
> + if (res.attr_bitmask[2] & FATTR4_WORD2_SECURITY_LABEL) {
> + server->caps |= NFS_CAP_SECURITY_LABEL;
> + } else
> +#endif
> + server->attr_bitmask[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
> +
> + if (server->caps & NFS_CAP_SECURITY_LABEL) {
> + memcpy(server->attr_bitmask_nl, res.attr_bitmask,
> + sizeof(server->attr_bitmask));
> + server->attr_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
> + }
>
> memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask));
> server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE;
> - server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY;
> + server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA |
> + FATTR4_WORD1_TIME_MODIFY;
> + server->cache_consistency_bitmask[2] &= FATTR4_WORD2_SECURITY_LABEL;
> + memcpy(server->cache_consistency_bitmask_nl, server->cache_consistency_bitmask,
> + sizeof(server->cache_consistency_bitmask_nl));
> + server->cache_consistency_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
> server->acl_bitmask = res.acl_bitmask;
> server->fh_expire_type = res.fh_expire_type;
> }
> @@ -2399,8 +2459,9 @@ int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
> static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
> struct nfs_fsinfo *info)
> {
> + u32 bitmask[3];
> struct nfs4_lookup_root_arg args = {
> - .bitmask = nfs4_fattr_bitmap,
> + .bitmask = bitmask,
> };
> struct nfs4_lookup_res res = {
> .server = server,
> @@ -2413,6 +2474,13 @@ static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
> .rpc_resp = &res,
> };
>
> + bitmask[0] = nfs4_fattr_bitmap[0];
> + bitmask[1] = nfs4_fattr_bitmap[1];
> + /*
> + * Process the label in the upcoming getfattr
> + */
> + bitmask[2] = nfs4_fattr_bitmap[2] & ~FATTR4_WORD2_SECURITY_LABEL;
> +
> nfs_fattr_init(info->fattr);
> return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
> }
> @@ -2599,7 +2667,10 @@ static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
> .rpc_argp = &args,
> .rpc_resp = &res,
> };
> -
> +
> + if (!label)
> + args.bitmask = server->attr_bitmask_nl;
> +
> nfs_fattr_init(fattr);
> return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
> }
> @@ -2694,6 +2765,7 @@ static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir,
> struct nfs4_lookup_res res = {
> .server = server,
> .fattr = fattr,
> + .label = label,
> .fh = fhandle,
> };
> struct rpc_message msg = {
> @@ -2702,6 +2774,9 @@ static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir,
> .rpc_resp = &res,
> };
>
> + if (label == NULL)
> + args.bitmask = server->attr_bitmask_nl;
> +
> nfs_fattr_init(fattr);
>
> dprintk("NFS call lookup %s\n", name->name);
> @@ -2808,7 +2883,7 @@ static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry
> .rpc_cred = entry->cred,
> };
> int mode = entry->mask;
> - int status;
> + int status = 0;
>
> /*
> * Determine which access bits we want to ask for...
> @@ -2923,7 +2998,7 @@ static int
> nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
> int flags)
> {
> - struct nfs4_label *ilabel = NULL;
> + struct nfs4_label l, *ilabel = NULL;
> struct nfs_open_context *ctx;
> struct nfs4_state *state;
> int status = 0;
> @@ -2932,6 +3007,8 @@ nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
> if (IS_ERR(ctx))
> return PTR_ERR(ctx);
>
> + ilabel = nfs4_label_init_security(dir, dentry, sattr, &l);
> +
> sattr->ia_mode &= ~current_umask();
> state = nfs4_do_open(dir, dentry, ctx->mode,
> flags, sattr, ilabel, ctx->cred,
> @@ -2945,6 +3022,7 @@ nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
> nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
> ctx->state = state;
> out:
> + nfs4_label_release_security(ilabel);
> put_nfs_open_context(ctx);
> return status;
> }
> @@ -2994,6 +3072,8 @@ static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
> res->server = server;
> msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE];
> nfs41_init_sequence(&args->seq_args, &res->seq_res, 1);
> +
> + nfs_fattr_init(res->dir_attr);
> }
>
> static void nfs4_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
> @@ -3263,14 +3343,19 @@ static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
> struct page *page, unsigned int len, struct iattr *sattr)
> {
> struct nfs4_exception exception = { };
> - struct nfs4_label *label = NULL;
> + struct nfs4_label l, *label = NULL;
> int err;
> +
> + label = nfs4_label_init_security(dir, dentry, sattr, &l);
> +
> do {
> err = nfs4_handle_exception(NFS_SERVER(dir),
> _nfs4_proc_symlink(dir, dentry, page,
> len, sattr, label),
> &exception);
> } while (exception.retry);
> +
> + nfs4_label_release_security(label);
> return err;
> }
>
> @@ -3296,15 +3381,19 @@ static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
> struct iattr *sattr)
> {
> struct nfs4_exception exception = { };
> - struct nfs4_label *label = NULL;
> + struct nfs4_label l, *label = NULL;
> int err;
>
> + label = nfs4_label_init_security(dir, dentry, sattr, &l);
> +
> sattr->ia_mode &= ~current_umask();
> do {
> err = nfs4_handle_exception(NFS_SERVER(dir),
> _nfs4_proc_mkdir(dir, dentry, sattr, label),
> &exception);
> } while (exception.retry);
> + nfs4_label_release_security(label);
> +
> return err;
> }
>
> @@ -3320,7 +3409,9 @@ static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
> .bitmask = NFS_SERVER(dentry->d_inode)->attr_bitmask,
> .plus = plus,
> };
> - struct nfs4_readdir_res res;
> + struct nfs4_readdir_res res = {
> + .pgbase = 0,
> + };
> struct rpc_message msg = {
> .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR],
> .rpc_argp = &args,
> @@ -3400,15 +3491,20 @@ static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
> struct iattr *sattr, dev_t rdev)
> {
> struct nfs4_exception exception = { };
> - struct nfs4_label *label = NULL;
> + struct nfs4_label l, *label = NULL;
> int err;
>
> + label = nfs4_label_init_security(dir, dentry, sattr, &l);
> +
> sattr->ia_mode &= ~current_umask();
> do {
> err = nfs4_handle_exception(NFS_SERVER(dir),
> _nfs4_proc_mknod(dir, dentry, sattr, label, rdev),
> &exception);
> } while (exception.retry);
> +
> + nfs4_label_release_security(label);
> +
> return err;
> }
>
> @@ -3624,7 +3720,11 @@ static void nfs4_proc_write_setup(struct nfs_write_data *data, struct rpc_messag
> data->args.bitmask = NULL;
> data->res.fattr = NULL;
> } else
> +#ifdef CONFIG_NFS_V4_SECURITY_LABEL
> + data->args.bitmask = server->cache_consistency_bitmask_nl;
> +#else
> data->args.bitmask = server->cache_consistency_bitmask;
> +#endif
>
> if (!data->write_done_cb)
> data->write_done_cb = nfs4_write_done_cb;
> @@ -4049,6 +4149,178 @@ static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen
> return err;
> }
>
> +#ifdef CONFIG_NFS_V4_SECURITY_LABEL
> +static int _nfs4_get_security_label(struct inode *inode, void *buf,
> + size_t buflen)
> +{
> + struct nfs_server *server = NFS_SERVER(inode);
> + struct nfs_fattr fattr;
> + struct nfs4_label label = {0, 0, buflen, buf};
> + u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL };
> + struct nfs4_getattr_arg args = {
> + .fh = NFS_FH(inode),
> + .bitmask = bitmask,
> + };
> + struct nfs4_getattr_res res = {
> + .fattr = &fattr,
> + .label = &label,
> + .server = server,
> + };
> + struct rpc_message msg = {
> + .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
> + .rpc_argp = &args,
> + .rpc_resp = &res,
> + };
> + int ret;
> +
> + nfs_fattr_init(&fattr);
> +
> + ret = rpc_call_sync(server->client, &msg, 0);
> + if (ret)
> + return ret;
> + if (!(fattr.valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL))
> + return -ENOENT;
> + if (buflen < label.len)
> + return -ERANGE;
> + return 0;
> +}
> +
> +static int nfs4_get_security_label(struct inode *inode, void *buf,
> + size_t buflen)
> +{
> + struct nfs4_exception exception = { };
> + int err;
> +
> + if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
> + return -EOPNOTSUPP;
> +
> + do {
> + err = nfs4_handle_exception(NFS_SERVER(inode),
> + _nfs4_get_security_label(inode, buf, buflen),
> + &exception);
> + } while (exception.retry);
> + return err;
> +}
> +
> +static int _nfs4_do_set_security_label(struct inode *inode,
> + struct nfs4_label *ilabel,
> + struct nfs_fattr *fattr,
> + struct nfs4_label *olabel,
> + struct nfs4_state *state)
> +{
> +
> + struct iattr sattr = {0};
> + struct nfs_server *server = NFS_SERVER(inode);
> + const u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL };
> + struct nfs_setattrargs args = {
> + .fh = NFS_FH(inode),
> + .iap = &sattr,
> + .server = server,
> + .bitmask = bitmask,
> + .label = ilabel,
> + };
> + struct nfs_setattrres res = {
> + .fattr = fattr,
> + .label = olabel,
> + .server = server,
> + };
> + struct rpc_message msg = {
> + .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
> + .rpc_argp = &args,
> + .rpc_resp = &res,
> + };
> + unsigned long timestamp = jiffies;
> + int status;
> +
> + if (state != NULL) {
> + struct nfs_lockowner lockowner = {
> + .l_owner = current->files,
> + .l_pid = current->tgid,
> + };
> +
> + msg.rpc_cred = state->owner->so_cred;
> + nfs4_select_rw_stateid(&args.stateid, state, FMODE_WRITE,
> + &lockowner);
> + } else if (nfs4_copy_delegation_stateid(&args.stateid, inode,
> + FMODE_WRITE)) {
> + /* Use that stateid */
> + } else
> + nfs4_stateid_copy(&args.stateid, &zero_stateid);
> +
> + status = rpc_call_sync(server->client, &msg, 0);
> + if (status == 0 && state != NULL)
> + renew_lease(server, timestamp);
> + return status;
> +}
> +
> +static int nfs4_do_set_security_label(struct inode *inode,
> + struct nfs4_label *ilabel,
> + struct nfs_fattr *fattr,
> + struct nfs4_label *olabel,
> + struct nfs4_state *state)
> +{
> + struct nfs4_exception exception = { };
> + int err;
> +
> + do {
> + err = nfs4_handle_exception(NFS_SERVER(inode),
> + _nfs4_do_set_security_label(inode, ilabel,
> + fattr, olabel, state),
> + &exception);
> + } while (exception.retry);
> + return err;
> +}
> +
> +static int
> +nfs4_set_security_label(struct dentry *dentry, const void *buf, size_t buflen)
> +{
> + struct nfs4_label ilabel, *olabel = NULL;
> + struct nfs_fattr fattr;
> + struct rpc_cred *cred;
> + struct nfs_open_context *ctx;
> + struct nfs4_state *state = NULL;
> + struct inode *inode = dentry->d_inode;
> + int status;
> +
> + if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
> + return -EOPNOTSUPP;
> +
> + nfs_fattr_init(&fattr);
> +
> + ilabel.pi = 0;
> + ilabel.lfs = 0;
> + ilabel.label = (char *)buf;
> + ilabel.len = buflen;
> +
> + cred = rpc_lookup_cred();
> + if (IS_ERR(cred))
> + return PTR_ERR(cred);
> +
> + olabel = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
> + if (IS_ERR(olabel)) {
> + status = -PTR_ERR(olabel);
> + goto out;
> + }
> +
> + /* Search for an existing open(O_WRITE) file */
> + ctx = nfs_find_open_context(inode, cred, FMODE_WRITE);
> + if (ctx != NULL)
> + state = ctx->state;
> +
> + status = nfs4_do_set_security_label(inode, &ilabel, &fattr, olabel,
> + state);
> + if (status == 0)
> + nfs_setsecurity(inode, &fattr, olabel);
> + if (ctx != NULL)
> + put_nfs_open_context(ctx);
> + nfs4_label_free(olabel);
> +out:
> + put_rpccred(cred);
> + return status;
> +}
> +#endif /* CONFIG_NFS_V4_SECURITY_LABEL */
> +
> +
> static int
> nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server, struct nfs4_state *state)
> {
> @@ -4337,7 +4609,7 @@ static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, co
> nfs41_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
> data->args.fhandle = &data->fh;
> data->args.stateid = &data->stateid;
> - data->args.bitmask = server->cache_consistency_bitmask;
> + data->args.bitmask = server->cache_consistency_bitmask_nl;
> nfs_copy_fh(&data->fh, NFS_FH(inode));
> nfs4_stateid_copy(&data->stateid, stateid);
> data->res.fattr = &data->fattr;
> diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
> index a9353d1..3725433 100644
> --- a/fs/nfs/nfs4xdr.c
> +++ b/fs/nfs/nfs4xdr.c
> @@ -102,12 +102,23 @@ static int nfs4_stat_to_errno(int);
> #define nfs4_path_maxsz (1 + ((3 + NFS4_MAXPATHLEN) >> 2))
> #define nfs4_owner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
> #define nfs4_group_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
> +#ifdef CONFIG_NFS_V4_SECURITY_LABEL
> +/* PI(4 bytes) + LFS(4 bytes) + 1(for null terminator?) + MAXLABELLEN */
> +#define nfs4_label_maxsz (4 + 4 + 1 + XDR_QUADLEN(NFS4_MAXLABELLEN))
> +#define encode_readdir_space 24
> +#define encode_readdir_bitmask_sz 3
> +#else
> +#define nfs4_label_maxsz 0
> +#define encode_readdir_space 20
> +#define encode_readdir_bitmask_sz 2
> +#endif
> /* We support only one layout type per file system */
> #define decode_mdsthreshold_maxsz (1 + 1 + nfs4_fattr_bitmap_maxsz + 1 + 8)
> /* This is based on getfattr, which uses the most attributes: */
> #define nfs4_fattr_value_maxsz (1 + (1 + 2 + 2 + 4 + 2 + 1 + 1 + 2 + 2 + \
> 3 + 3 + 3 + nfs4_owner_maxsz + \
> - nfs4_group_maxsz + decode_mdsthreshold_maxsz))
> + nfs4_group_maxsz + nfs4_label_maxsz + \
> + decode_mdsthreshold_maxsz))
> #define nfs4_fattr_maxsz (nfs4_fattr_bitmap_maxsz + \
> nfs4_fattr_value_maxsz)
> #define decode_getattr_maxsz (op_decode_hdr_maxsz + nfs4_fattr_maxsz)
> @@ -115,6 +126,7 @@ static int nfs4_stat_to_errno(int);
> 1 + 2 + 1 + \
> nfs4_owner_maxsz + \
> nfs4_group_maxsz + \
> + nfs4_label_maxsz + \
> 4 + 4)
> #define encode_savefh_maxsz (op_encode_hdr_maxsz)
> #define decode_savefh_maxsz (op_decode_hdr_maxsz)
> @@ -192,9 +204,11 @@ static int nfs4_stat_to_errno(int);
> encode_stateid_maxsz + 3)
> #define decode_read_maxsz (op_decode_hdr_maxsz + 2)
> #define encode_readdir_maxsz (op_encode_hdr_maxsz + \
> - 2 + encode_verifier_maxsz + 5)
> + 2 + encode_verifier_maxsz + 5 + \
> + nfs4_label_maxsz)
> #define decode_readdir_maxsz (op_decode_hdr_maxsz + \
> - decode_verifier_maxsz)
> + decode_verifier_maxsz + \
> + nfs4_label_maxsz + nfs4_fattr_maxsz)
> #define encode_readlink_maxsz (op_encode_hdr_maxsz)
> #define decode_readlink_maxsz (op_decode_hdr_maxsz + 1)
> #define encode_write_maxsz (op_encode_hdr_maxsz + \
> @@ -972,7 +986,9 @@ static void encode_nfs4_verifier(struct xdr_stream *xdr, const nfs4_verifier *ve
> encode_opaque_fixed(xdr, verf->data, NFS4_VERIFIER_SIZE);
> }
>
> -static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const struct nfs_server *server)
> +static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap,
> + const struct nfs4_label *label,
> + const struct nfs_server *server)
> {
> char owner_name[IDMAP_NAMESZ];
> char owner_group[IDMAP_NAMESZ];
> @@ -1022,6 +1038,8 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const
> }
> len += 4 + (XDR_QUADLEN(owner_grouplen) << 2);
> }
> + if (label)
> + len += 4 + 4 + 4 + (XDR_QUADLEN(label->len) << 2);
> if (iap->ia_valid & ATTR_ATIME_SET)
> len += 16;
> else if (iap->ia_valid & ATTR_ATIME)
> @@ -1078,6 +1096,13 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const
> bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET;
> *p++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME);
> }
> + if (label) {
> + bmval2 |= FATTR4_WORD2_SECURITY_LABEL;
> + *p++ = cpu_to_be32(label->lfs);
> + *p++ = cpu_to_be32(label->pi);
> + *p++ = cpu_to_be32(label->len);
> + p = xdr_encode_opaque_fixed(p, label->label, label->len);
> + }
>
> /*
> * Now we backfill the bitmap and the attribute buffer length.
> @@ -1144,7 +1169,7 @@ static void encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg *
> }
>
> encode_string(xdr, create->name->len, create->name->name);
> - encode_attrs(xdr, create->attrs, create->server);
> + encode_attrs(xdr, create->attrs, create->label, create->server);
> }
>
> static void encode_getattr_one(struct xdr_stream *xdr, uint32_t bitmap, struct compound_hdr *hdr)
> @@ -1377,21 +1402,23 @@ static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_op
> switch(arg->open_flags & O_EXCL) {
> case 0:
> *p = cpu_to_be32(NFS4_CREATE_UNCHECKED);
> - encode_attrs(xdr, arg->u.attrs, arg->server);
> + encode_attrs(xdr, arg->u.attrs, arg->label, arg->server);
> break;
> default:
> clp = arg->server->nfs_client;
> if (clp->cl_mvops->minor_version > 0) {
> if (nfs4_has_persistent_session(clp)) {
> *p = cpu_to_be32(NFS4_CREATE_GUARDED);
> - encode_attrs(xdr, arg->u.attrs, arg->server);
> + encode_attrs(xdr, arg->u.attrs, arg->label,
> + arg->server);
> } else {
> struct iattr dummy;
>
> *p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE4_1);
> encode_nfs4_verifier(xdr, &arg->u.verifier);
> dummy.ia_valid = 0;
> - encode_attrs(xdr, &dummy, arg->server);
> + encode_attrs(xdr, &dummy, arg->label,
> + arg->server);
> }
> } else {
> *p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE);
> @@ -1570,20 +1597,34 @@ static void encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg
> encode_op_hdr(xdr, OP_READDIR, decode_readdir_maxsz, hdr);
> encode_uint64(xdr, readdir->cookie);
> encode_nfs4_verifier(xdr, &readdir->verifier);
> - p = reserve_space(xdr, 20);
> + p = reserve_space(xdr, encode_readdir_space);
> *p++ = cpu_to_be32(dircount);
> *p++ = cpu_to_be32(readdir->count);
> - *p++ = cpu_to_be32(2);
> -
> + *p++ = cpu_to_be32(encode_readdir_bitmask_sz);
> *p++ = cpu_to_be32(attrs[0] & readdir->bitmask[0]);
> - *p = cpu_to_be32(attrs[1] & readdir->bitmask[1]);
> + *p = cpu_to_be32(attrs[1] & readdir->bitmask[1]);
> + if (encode_readdir_bitmask_sz > 2) {
> + p++, *p++ = cpu_to_be32(readdir->bitmask[2]);
> + }
> memcpy(verf, readdir->verifier.data, sizeof(verf));
> - dprintk("%s: cookie = %Lu, verifier = %08x:%08x, bitmap = %08x:%08x\n",
> +
> +#ifdef CONFIG_NFS_V4_SECURITY_LABEL
> + dprintk("%s: cookie = %llu, verifier = %08x:%08x, bitmap = %08x:%08x:%08x\n",
> + __func__,
> + (unsigned long long)readdir->cookie,
> + verf[0], verf[1],
> + attrs[0] & readdir->bitmask[0],
> + attrs[1] & readdir->bitmask[1],
> + readdir->bitmask[2]);
> +#else
> + dprintk("%s: cookie = %llu, verifier = %08x:%08x, bitmap = %08x:%08x\n",
> __func__,
> (unsigned long long)readdir->cookie,
> verf[0], verf[1],
> attrs[0] & readdir->bitmask[0],
> attrs[1] & readdir->bitmask[1]);
> +#endif
> +
> }
>
> static void encode_readlink(struct xdr_stream *xdr, const struct nfs4_readlink *readlink, struct rpc_rqst *req, struct compound_hdr *hdr)
> @@ -1642,7 +1683,7 @@ static void encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs
> {
> encode_op_hdr(xdr, OP_SETATTR, decode_setattr_maxsz, hdr);
> encode_nfs4_stateid(xdr, &arg->stateid);
> - encode_attrs(xdr, arg->iap, server);
> + encode_attrs(xdr, arg->iap, arg->label, server);
> }
>
> static void encode_setclientid(struct xdr_stream *xdr, const struct nfs4_setclientid *setclientid, struct compound_hdr *hdr)
> @@ -4060,6 +4101,67 @@ static int decode_attr_time_delta(struct xdr_stream *xdr, uint32_t *bitmap,
> return status;
> }
>
> +static int decode_attr_security_label(struct xdr_stream *xdr, uint32_t *bitmap,
> + struct nfs4_label *label)
> +{
> + uint32_t pi = 0;
> + uint32_t lfs = 0;
> + __u32 len;
> + __be32 *p;
> + int status = 0;
> +
> + if (unlikely(bitmap[2] & (FATTR4_WORD2_SECURITY_LABEL - 1U)))
> + return -EIO;
> + if (likely(bitmap[2] & FATTR4_WORD2_SECURITY_LABEL)) {
> + p = xdr_inline_decode(xdr, 4);
> + if (unlikely(!p))
> + goto out_overflow;
> + lfs = be32_to_cpup(p++);
> + p = xdr_inline_decode(xdr, 4);
> + if (unlikely(!p))
> + goto out_overflow;
> + pi = be32_to_cpup(p++);
> + p = xdr_inline_decode(xdr, 4);
> + if (unlikely(!p))
> + goto out_overflow;
> + len = be32_to_cpup(p++);
> + p = xdr_inline_decode(xdr, len);
> + if (unlikely(!p))
> + goto out_overflow;
> + if (len < XDR_MAX_NETOBJ) {
> + if (label) {
> + nfs4_label_init(label);
> + if (label->len < len) {
If I remember the earlier patch right, nfs4_label_init() just set
label->len to NFS4_MAXLABELLEN.
Doesn't that overwrite the length that was passed into
nfs4_get_security_label?
This doesn't seem right.
--b.
> + printk(KERN_ERR
> + "%s(): label->len %d < len %d\n",
> + __func__, label->len, len);
> + } else {
> + memcpy(label->label, p, len);
> + label->len = len;
> + label->pi = pi;
> + label->lfs = lfs;
> + status = NFS_ATTR_FATTR_V4_SECURITY_LABEL;
> + }
> + } else {
> + printk("%s(): NULL label.\n", __func__);
> + dump_stack();
> + goto out_overflow;
> + }
> + bitmap[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
> + } else
> + printk(KERN_WARNING "%s: label too long (%u)!\n",
> + __func__, len);
> + }
> + if (label && label->label)
> + dprintk("%s: label=%s, len=%d, PI=%d, LFS=%d\n", __func__,
> + (char *)label->label, label->len, label->pi, label->lfs);
> + return status;
> +
> +out_overflow:
> + print_overflow_msg(__func__, xdr);
> + return -EIO;
> +}
> +
> static int decode_attr_time_modify(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
> {
> int status = 0;
> @@ -4402,7 +4504,7 @@ out_overflow:
>
> static int decode_getfattr_attrs(struct xdr_stream *xdr, uint32_t *bitmap,
> struct nfs_fattr *fattr, struct nfs_fh *fh,
> - struct nfs4_fs_locations *fs_loc,
> + struct nfs4_fs_locations *fs_loc, struct nfs4_label *label,
> const struct nfs_server *server)
> {
> int status;
> @@ -4510,6 +4612,11 @@ static int decode_getfattr_attrs(struct xdr_stream *xdr, uint32_t *bitmap,
> if (status < 0)
> goto xdr_error;
>
> + status = decode_attr_security_label(xdr, bitmap, label);
> + if (status < 0)
> + goto xdr_error;
> + fattr->valid |= status;
> +
> xdr_error:
> dprintk("%s: xdr returned %d\n", __func__, -status);
> return status;
> @@ -4517,7 +4624,7 @@ xdr_error:
>
> static int decode_getfattr_generic(struct xdr_stream *xdr, struct nfs_fattr *fattr,
> struct nfs_fh *fh, struct nfs4_fs_locations *fs_loc,
> - const struct nfs_server *server)
> + struct nfs4_label *label, const struct nfs_server *server)
> {
> unsigned int savep;
> uint32_t attrlen,
> @@ -4536,7 +4643,8 @@ static int decode_getfattr_generic(struct xdr_stream *xdr, struct nfs_fattr *fat
> if (status < 0)
> goto xdr_error;
>
> - status = decode_getfattr_attrs(xdr, bitmap, fattr, fh, fs_loc, server);
> + status = decode_getfattr_attrs(xdr, bitmap, fattr, fh, fs_loc,
> + label, server);
> if (status < 0)
> goto xdr_error;
>
> @@ -4547,9 +4655,9 @@ xdr_error:
> }
>
> static int decode_getfattr(struct xdr_stream *xdr, struct nfs_fattr *fattr,
> - const struct nfs_server *server)
> + struct nfs4_label *label, const struct nfs_server *server)
> {
> - return decode_getfattr_generic(xdr, fattr, NULL, NULL, server);
> + return decode_getfattr_generic(xdr, fattr, NULL, NULL, label, server);
> }
>
> /*
> @@ -5883,7 +5991,7 @@ static int nfs4_xdr_dec_open_downgrade(struct rpc_rqst *rqstp,
> status = decode_open_downgrade(xdr, res);
> if (status != 0)
> goto out;
> - decode_getfattr(xdr, res->fattr, res->server);
> + decode_getfattr(xdr, res->fattr, res->label, res->server);
> out:
> return status;
> }
> @@ -5909,7 +6017,7 @@ static int nfs4_xdr_dec_access(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
> status = decode_access(xdr, &res->supported, &res->access);
> if (status != 0)
> goto out;
> - decode_getfattr(xdr, res->fattr, res->server);
> + decode_getfattr(xdr, res->fattr, res->label, res->server);
> out:
> return status;
> }
> @@ -5938,7 +6046,7 @@ static int nfs4_xdr_dec_lookup(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
> status = decode_getfh(xdr, res->fh);
> if (status)
> goto out;
> - status = decode_getfattr(xdr, res->fattr, res->server);
> + status = decode_getfattr(xdr, res->fattr, res->label, res->server);
> out:
> return status;
> }
> @@ -5964,7 +6072,8 @@ static int nfs4_xdr_dec_lookup_root(struct rpc_rqst *rqstp,
> goto out;
> status = decode_getfh(xdr, res->fh);
> if (status == 0)
> - status = decode_getfattr(xdr, res->fattr, res->server);
> + status = decode_getfattr(xdr, res->fattr,
> + res->label, res->server);
> out:
> return status;
> }
> @@ -6055,7 +6164,7 @@ static int nfs4_xdr_dec_link(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
> status = decode_restorefh(xdr);
> if (status)
> goto out;
> - decode_getfattr(xdr, res->fattr, res->server);
> + decode_getfattr(xdr, res->fattr, res->label, res->server);
> out:
> return status;
> }
> @@ -6084,7 +6193,7 @@ static int nfs4_xdr_dec_create(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
> status = decode_getfh(xdr, res->fh);
> if (status)
> goto out;
> - decode_getfattr(xdr, res->fattr, res->server);
> + decode_getfattr(xdr, res->fattr, res->label, res->server);
> out:
> return status;
> }
> @@ -6116,7 +6225,7 @@ static int nfs4_xdr_dec_getattr(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
> status = decode_putfh(xdr);
> if (status)
> goto out;
> - status = decode_getfattr(xdr, res->fattr, res->server);
> + status = decode_getfattr(xdr, res->fattr, res->label, res->server);
> out:
> return status;
> }
> @@ -6218,7 +6327,7 @@ static int nfs4_xdr_dec_close(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
> * an ESTALE error. Shouldn't be a problem,
> * though, since fattr->valid will remain unset.
> */
> - decode_getfattr(xdr, res->fattr, res->server);
> + decode_getfattr(xdr, res->fattr, res->label, res->server);
> out:
> return status;
> }
> @@ -6249,7 +6358,7 @@ static int nfs4_xdr_dec_open(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
> goto out;
> if (res->access_request)
> decode_access(xdr, &res->access_supported, &res->access_result);
> - decode_getfattr(xdr, res->f_attr, res->server);
> + decode_getfattr(xdr, res->f_attr, res->f_label, res->server);
> out:
> return status;
> }
> @@ -6299,7 +6408,7 @@ static int nfs4_xdr_dec_open_noattr(struct rpc_rqst *rqstp,
> goto out;
> if (res->access_request)
> decode_access(xdr, &res->access_supported, &res->access_result);
> - decode_getfattr(xdr, res->f_attr, res->server);
> + decode_getfattr(xdr, res->f_attr, NULL, res->server);
> out:
> return status;
> }
> @@ -6326,7 +6435,7 @@ static int nfs4_xdr_dec_setattr(struct rpc_rqst *rqstp,
> status = decode_setattr(xdr);
> if (status)
> goto out;
> - decode_getfattr(xdr, res->fattr, res->server);
> + decode_getfattr(xdr, res->fattr, res->label, res->server);
> out:
> return status;
> }
> @@ -6506,7 +6615,7 @@ static int nfs4_xdr_dec_write(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
> if (status)
> goto out;
> if (res->fattr)
> - decode_getfattr(xdr, res->fattr, res->server);
> + decode_getfattr(xdr, res->fattr, NULL, res->server);
> if (!status)
> status = res->count;
> out:
> @@ -6687,7 +6796,7 @@ static int nfs4_xdr_dec_delegreturn(struct rpc_rqst *rqstp,
> status = decode_putfh(xdr);
> if (status != 0)
> goto out;
> - status = decode_getfattr(xdr, res->fattr, res->server);
> + status = decode_getfattr(xdr, res->fattr, res->label, res->server);
> if (status != 0)
> goto out;
> status = decode_delegreturn(xdr);
> @@ -6720,7 +6829,7 @@ static int nfs4_xdr_dec_fs_locations(struct rpc_rqst *req,
> xdr_enter_page(xdr, PAGE_SIZE);
> status = decode_getfattr_generic(xdr, &res->fs_locations->fattr,
> NULL, res->fs_locations,
> - res->fs_locations->server);
> + NULL, res->fs_locations->server);
> out:
> return status;
> }
> @@ -7001,7 +7110,7 @@ static int nfs4_xdr_dec_layoutcommit(struct rpc_rqst *rqstp,
> status = decode_layoutcommit(xdr, rqstp, res);
> if (status)
> goto out;
> - decode_getfattr(xdr, res->fattr, res->server);
> + decode_getfattr(xdr, res->fattr, NULL, res->server);
> out:
> return status;
> }
> @@ -7133,7 +7242,7 @@ int nfs4_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry,
> goto out_overflow;
>
> if (decode_getfattr_attrs(xdr, bitmap, entry->fattr, entry->fh,
> - NULL, entry->server) < 0)
> + NULL, entry->label, entry->server) < 0)
> goto out_overflow;
> if (entry->fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID)
> entry->ino = entry->fattr->mounted_on_fileid;
> diff --git a/fs/nfs/super.c b/fs/nfs/super.c
> index c98b434..4e78f93 100644
> --- a/fs/nfs/super.c
> +++ b/fs/nfs/super.c
> @@ -2419,8 +2419,21 @@ static int nfs_bdi_register(struct nfs_server *server)
> int nfs_set_sb_security(struct super_block *s, struct dentry *mntroot,
> struct nfs_mount_info *mount_info)
> {
> - return security_sb_set_mnt_opts(s, &mount_info->parsed->lsm_opts,
> - 0, NULL);
> + int error;
> + unsigned long kflags = 0, kflags_out = 0;
> + if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL)
> + kflags |= SECURITY_LSM_NATIVE_LABELS;
> +
> + error = security_sb_set_mnt_opts(s, &mount_info->parsed->lsm_opts,
> + kflags, &kflags_out);
> + if (error)
> + goto err;
> +
> + if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL &&
> + !(kflags_out & SECURITY_LSM_NATIVE_LABELS))
> + NFS_SB(s)->caps &= ~NFS_CAP_SECURITY_LABEL;
> +err:
> + return error;
> }
> EXPORT_SYMBOL_GPL(nfs_set_sb_security);
>
> diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
> index 41b0b6d..ff4f72a 100644
> --- a/include/linux/nfs_fs.h
> +++ b/include/linux/nfs_fs.h
> @@ -199,6 +199,7 @@ struct nfs_inode {
> #define NFS_INO_INVALID_ACL 0x0010 /* cached acls are invalid */
> #define NFS_INO_REVAL_PAGECACHE 0x0020 /* must revalidate pagecache */
> #define NFS_INO_REVAL_FORCED 0x0040 /* force revalidation ignoring a delegation */
> +#define NFS_INO_INVALID_LABEL 0x0080 /* cached label is invalid */
>
> /*
> * Bit offsets in flags field
> @@ -344,6 +345,8 @@ extern int __nfs_revalidate_inode(struct nfs_server *, struct inode *);
> extern int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping);
> extern int nfs_setattr(struct dentry *, struct iattr *);
> extern void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr);
> +extern void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr,
> + struct nfs4_label *label);
> extern struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx);
> extern void put_nfs_open_context(struct nfs_open_context *ctx);
> extern struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode);
> diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
> index e6ed3c2..2a4f1d4 100644
> --- a/include/linux/nfs_fs_sb.h
> +++ b/include/linux/nfs_fs_sb.h
> @@ -145,11 +145,18 @@ struct nfs_server {
> u32 attr_bitmask[3];/* V4 bitmask representing the set
> of attributes supported on this
> filesystem */
> + u32 attr_bitmask_nl[3];
> + /* V4 bitmask representing the
> + set of attributes supported
> + on this filesystem excluding
> + the label support bit. */
> u32 cache_consistency_bitmask[3];
> /* V4 bitmask representing the subset
> of change attribute, size, ctime
> and mtime attributes supported by
> the server */
> + u32 cache_consistency_bitmask_nl[3];
> + /* As above, excluding label. */
> u32 acl_bitmask; /* V4 bitmask representing the ACEs
> that are supported on this
> filesystem */
> diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
> index dda436f..af947f8 100644
> --- a/security/selinux/hooks.c
> +++ b/security/selinux/hooks.c
> @@ -2876,7 +2876,10 @@ static void selinux_inode_post_setxattr(struct dentry *dentry, const char *name,
> return;
> }
>
> + isec->sclass = inode_mode_to_security_class(inode->i_mode);
> isec->sid = newsid;
> + isec->initialized = 1;
> +
> return;
> }
>
> @@ -2964,6 +2967,7 @@ static int selinux_inode_setsecurity(struct inode *inode, const char *name,
> if (rc)
> return rc;
>
> + isec->sclass = inode_mode_to_security_class(inode->i_mode);
> isec->sid = newsid;
> isec->initialized = 1;
> return 0;
> --
> 1.7.11.7
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 06/15] NFSv4: Introduce new label structure
2013-02-12 22:40 ` Myklebust, Trond
@ 2013-02-12 23:06 ` J. Bruce Fields
2013-02-13 0:30 ` Steve Dickson
0 siblings, 1 reply; 58+ messages in thread
From: J. Bruce Fields @ 2013-02-12 23:06 UTC (permalink / raw)
To: Myklebust, Trond
Cc: Steve Dickson, J. Bruce Fields, David P. Quigley, Linux NFS list,
Linux FS devel list, Linux Security List, SELinux List
On Tue, Feb 12, 2013 at 10:40:46PM +0000, Myklebust, Trond wrote:
> On Tue, 2013-02-12 at 17:32 -0500, J. Bruce Fields wrote:
> > On Tue, Feb 12, 2013 at 10:28:16PM +0000, Myklebust, Trond wrote:
> > > On Tue, 2013-02-12 at 17:07 -0500, J. Bruce Fields wrote:
> > > > On Fri, Feb 08, 2013 at 07:39:14AM -0500, Steve Dickson wrote:
> > > > > From: David Quigley <dpquigl@davequigley.com>
> > > > >
> > > > > In order to mimic the way that NFSv4 ACLs are implemented we have created a
> > > > > structure to be used to pass label data up and down the call chain. This patch
> > > > > adds the new structure and new members to the required NFSv4 call structures.
> > > > >
> > > > > Signed-off-by: Matthew N. Dodd <Matthew.Dodd@sparta.com>
> > > > > Signed-off-by: Miguel Rodel Felipe <Rodel_FM@dsi.a-star.edu.sg>
> > > > > Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene@dsi.a-star.edu.sg>
> > > > > Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG@dsi.a-star.edu.sg>
> > > > > ---
> > > > > fs/nfs/inode.c | 33 +++++++++++++++++++++++++++++++++
> > > > > include/linux/nfs4.h | 7 +++++++
> > > > > include/linux/nfs_fs.h | 17 +++++++++++++++++
> > > > > include/linux/nfs_xdr.h | 21 +++++++++++++++++++++
> > > > > include/uapi/linux/nfs4.h | 2 +-
> > > > > 5 files changed, 79 insertions(+), 1 deletion(-)
> > > > >
> > > > > diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
> > > > > index ebeb94c..8d5f01b 100644
> > > > > --- a/fs/nfs/inode.c
> > > > > +++ b/fs/nfs/inode.c
> > > > > @@ -255,6 +255,39 @@ nfs_init_locked(struct inode *inode, void *opaque)
> > > > > return 0;
> > > > > }
> > > > >
> > > > > +#ifdef CONFIG_NFS_V4_SECURITY_LABEL
> > > > > +struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags)
> > > > > +{
> > > > > + struct nfs4_label *label = NULL;
> > > > > +
> > > > > + if (!(server->caps & NFS_CAP_SECURITY_LABEL))
> > > > > + return label;
> > > > > +
> > > > > + label = kzalloc(NFS4_MAXLABELLEN, flags);
> > > > > + if (label == NULL)
> > > > > + return ERR_PTR(-ENOMEM);
> > > > > +
> > > > > + label->label = (char *)(label + 1);
> > > > > + label->len = NFS4_MAXLABELLEN;
> > > >
> > > > If you're expecting to be able to store up to NFS4_MAXLABELLEN of data
> > > > after the end of the struct, then you want:
> > > >
> > > > label = kzalloc(sizeof(struct nfs4_label) + NFS4_MAXLABELLEN, flags);
> > >
> > > Sigh... No.
> > >
> > > I keep telling Steve that the 'label' needs to be defined as an array,
> >
> > Yeah, I know, he said in 0/15 that he couldn't do that, so I've been
> > reading through these on the assumption I'll find out why not at some
> > point.... (Still not seeing it, though.)
>
> It only makes sense to define label->label as a pointer if you need to
> change the pointer value at some time. However, if that is the case,
> then why allocate the struct nfs4_label and label string as a single
> memory block? It would make more sense to allocate them separately so
> that you can free the old label storage after you change the pointer.
nfs4_get_security_label() in a later patch is indeed using some
passed-in storage instead, but I'm not sure it's doing it correctly.
It would seem simpler to pick either inline or separate storage and
stick with it throughout.
I'd be inclined to favor inline even if it means larger allocations than
necessary or an extra copy. Just because it seems harder to mess up.
--b.
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 14/15] NFSD: Server implementation of MAC Labeling
2013-02-12 22:54 ` J. Bruce Fields
@ 2013-02-12 23:07 ` J. Bruce Fields
[not found] ` <20130212225425.GM10267-uC3wQj2KruNg9hUCZPvPmw@public.gmane.org>
1 sibling, 0 replies; 58+ messages in thread
From: J. Bruce Fields @ 2013-02-12 23:07 UTC (permalink / raw)
To: Steve Dickson
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On Tue, Feb 12, 2013 at 05:54:25PM -0500, bfields wrote:
> On Fri, Feb 08, 2013 at 07:39:22AM -0500, Steve Dickson wrote:
> > From: David Quigley <dpquigl@davequigley.com>
> >
> > This patch adds the ability to encode and decode file labels on the server for
> > the purpose of sending them to the client and also to process label change
> > requests from the client.
> >
> > Signed-off-by: Matthew N. Dodd <Matthew.Dodd@sparta.com>
> > Signed-off-by: Miguel Rodel Felipe <Rodel_FM@dsi.a-star.edu.sg>
> > Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene@dsi.a-star.edu.sg>
> > Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG@dsi.a-star.edu.sg>
> > ---
> > fs/nfsd/nfs4proc.c | 41 +++++++++++++++++++
> > fs/nfsd/nfs4xdr.c | 116 ++++++++++++++++++++++++++++++++++++++++++++++++++---
> > fs/nfsd/nfsd.h | 8 ++--
> > fs/nfsd/vfs.c | 30 ++++++++++++++
> > fs/nfsd/vfs.h | 2 +
> > fs/nfsd/xdr4.h | 3 ++
> > 6 files changed, 191 insertions(+), 9 deletions(-)
> >
> > diff --git a/fs/nfsd/nfs4proc.c b/fs/nfsd/nfs4proc.c
> > index 9d1c5db..898092d 100644
> > --- a/fs/nfsd/nfs4proc.c
> > +++ b/fs/nfsd/nfs4proc.c
> > @@ -42,6 +42,36 @@
> > #include "current_stateid.h"
> > #include "netns.h"
> >
> > +#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
> > +#include <linux/security.h>
> > +
> > +static inline void
> > +nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct nfs4_label *label, u32 *bmval)
> > +{
> > + struct inode *inode = resfh->fh_dentry->d_inode;
> > + int status;
> > +
> > + mutex_lock(&inode->i_mutex);
> > + status = security_inode_setsecctx(resfh->fh_dentry,
> > + label->label, label->len);
> > + mutex_unlock(&inode->i_mutex);
> > +
> > + if (status)
> > + /*
> > + * We should probably fail the whole open at this point,
> > + * but we've already created or opened the file, so it's
> > + * too late; So this seems the least of evils:
> > + */
> > + bmval[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
> > +
> > + return;
> > +}
> > +#else
> > +static inline void
> > +nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct nfs4_label *label, u32 *bmval)
> > +{ }
> > +#endif
> > +
> > #define NFSDDBG_FACILITY NFSDDBG_PROC
> >
> > static u32 nfsd_attrmask[] = {
> > @@ -230,6 +260,9 @@ do_open_lookup(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_o
> > (u32 *)open->op_verf.data,
> > &open->op_truncate, &open->op_created);
> >
> > + if (!status && open->op_label != NULL)
> > + nfsd4_security_inode_setsecctx(resfh, open->op_label, open->op_bmval);
> > +
> > /*
> > * Following rfc 3530 14.2.16, use the returned bitmask
> > * to indicate which attributes we used to store the
> > @@ -599,6 +632,9 @@ nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
> > if (status)
> > goto out;
> >
> > + if (create->cr_label != NULL)
> > + nfsd4_security_inode_setsecctx(&resfh, create->cr_label, create->cr_bmval);
> > +
> > if (create->cr_acl != NULL)
> > do_set_nfs4_acl(rqstp, &resfh, create->cr_acl,
> > create->cr_bmval);
> > @@ -888,6 +924,11 @@ nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
> > setattr->sa_acl);
> > if (status)
> > goto out;
> > + if (setattr->sa_label != NULL)
> > + status = nfsd4_set_nfs4_label(rqstp, &cstate->current_fh,
> > + setattr->sa_label);
> > + if (status)
> > + goto out;
> > status = nfsd_setattr(rqstp, &cstate->current_fh, &setattr->sa_iattr,
> > 0, (time_t)0);
> > out:
> > diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
> > index 0dc1158..0124b43 100644
> > --- a/fs/nfsd/nfs4xdr.c
> > +++ b/fs/nfsd/nfs4xdr.c
> > @@ -55,6 +55,11 @@
> > #include "cache.h"
> > #include "netns.h"
> >
> > +#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
> > +#include <linux/security.h>
> > +#endif
> > +
> > +
> > #define NFSDDBG_FACILITY NFSDDBG_XDR
> >
> > /*
> > @@ -242,7 +247,8 @@ nfsd4_decode_bitmap(struct nfsd4_compoundargs *argp, u32 *bmval)
> >
> > static __be32
> > nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval,
> > - struct iattr *iattr, struct nfs4_acl **acl)
> > + struct iattr *iattr, struct nfs4_acl **acl,
> > + struct nfs4_label **label)
> > {
> > int expected_len, len = 0;
> > u32 dummy32;
> > @@ -386,6 +392,50 @@ nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval,
> > goto xdr_error;
> > }
> > }
> > +#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
> > + if (bmval[2] & FATTR4_WORD2_SECURITY_LABEL) {
> > + uint32_t pi;
> > + uint32_t lfs;
> > +
> > + READ_BUF(4);
> > + len += 4;
> > + READ32(lfs);
> > + READ_BUF(4);
> > + len += 4;
> > + READ32(pi);
> > + READ_BUF(4);
> > + len += 4;
> > + READ32(dummy32);
> > + READ_BUF(dummy32);
> > + len += (XDR_QUADLEN(dummy32) << 2);
> > + READMEM(buf, dummy32);
> > +
> > + if (dummy32 > NFS4_MAXLABELLEN)
> > + return nfserr_resource;
> > +
> > + *label = kzalloc(sizeof(struct nfs4_label), GFP_KERNEL);
>
> So we don't want to allocate these the same way we did on the client?
>
> > + if (*label == NULL) {
> > + host_err = -ENOMEM;
> > + goto out_nfserr;
> > + }
> > +
> > + (*label)->label = kmalloc(dummy32 + 1, GFP_KERNEL);
> > + if ((*label)->label == NULL) {
> > + host_err = -ENOMEM;
> > + kfree(*label);
> > + goto out_nfserr;
> > + }
> > +
> > + (*label)->len = dummy32;
> > + memcpy((*label)->label, buf, dummy32);
> > + ((char *)(*label)->label)[dummy32] = '\0';
> > + (*label)->pi = pi;
> > + (*label)->lfs = lfs;
> > +
> > + defer_free(argp, kfree, (*label)->label);
> > + defer_free(argp, kfree, *label);
>
> Hm: looking at defer_free and nfsd4_release_compoundargs: looks like
> argp->to_free is effectively a stack, so these will get freed in the
> reverse order: *label first, then (*label)->label. That's trouble.
>
> So, I think we want the order of those two defer_free()'s reversed.
>
> Or we could just allocate the whole things as one chunk as on the client
> and not have to worry about this kind of thing. I think I'd prefer that
> to trying to keep the allocation as small as possible. We're only using
> this memory temporarily so it's not as though we need to have tons of
> struct nfs4_labels allocated at the same time anyway.
If you do want to stick with allocating label->label separately, please
just define a free_nfs4_label() and do one
defer_free(argp, free_nfs4_label, *label)
That'll be less fragile.
--b.
>
> > + }
> > +#endif
> > if (bmval[0] & ~NFSD_WRITEABLE_ATTRS_WORD0
> > || bmval[1] & ~NFSD_WRITEABLE_ATTRS_WORD1
> > || bmval[2] & ~NFSD_WRITEABLE_ATTRS_WORD2)
> > @@ -575,7 +625,7 @@ nfsd4_decode_create(struct nfsd4_compoundargs *argp, struct nfsd4_create *create
> > return status;
> >
> > status = nfsd4_decode_fattr(argp, create->cr_bmval, &create->cr_iattr,
> > - &create->cr_acl);
> > + &create->cr_acl, &create->cr_label);
> > if (status)
> > goto out;
> >
> > @@ -825,7 +875,7 @@ nfsd4_decode_open(struct nfsd4_compoundargs *argp, struct nfsd4_open *open)
> > case NFS4_CREATE_UNCHECKED:
> > case NFS4_CREATE_GUARDED:
> > status = nfsd4_decode_fattr(argp, open->op_bmval,
> > - &open->op_iattr, &open->op_acl);
> > + &open->op_iattr, &open->op_acl, &open->op_label);
> > if (status)
> > goto out;
> > break;
> > @@ -839,7 +889,7 @@ nfsd4_decode_open(struct nfsd4_compoundargs *argp, struct nfsd4_open *open)
> > READ_BUF(NFS4_VERIFIER_SIZE);
> > COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE);
> > status = nfsd4_decode_fattr(argp, open->op_bmval,
> > - &open->op_iattr, &open->op_acl);
> > + &open->op_iattr, &open->op_acl, &open->op_label);
> > if (status)
> > goto out;
> > break;
> > @@ -1061,7 +1111,7 @@ nfsd4_decode_setattr(struct nfsd4_compoundargs *argp, struct nfsd4_setattr *seta
> > if (status)
> > return status;
> > return nfsd4_decode_fattr(argp, setattr->sa_bmval, &setattr->sa_iattr,
> > - &setattr->sa_acl);
> > + &setattr->sa_acl, &setattr->sa_label);
> > }
> >
> > static __be32
> > @@ -1970,6 +2020,50 @@ nfsd4_encode_aclname(struct svc_rqst *rqstp, int whotype, uid_t id, int group,
> > FATTR4_WORD0_RDATTR_ERROR)
> > #define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID
> >
> > +#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
> > +static inline __be32
> > +nfsd4_encode_security_label(struct svc_rqst *rqstp, struct dentry *dentry, __be32 **pp, int *buflen)
> > +{
> > + void *context;
> > + int err;
> > + int len;
> > + uint32_t pi = 0;
> > + uint32_t lfs = 0;
> > + __be32 *p = *pp;
> > +
> > + err = 0;
> > + (void)security_inode_getsecctx(dentry->d_inode, &context, &len);
> > + if (len < 0)
> > + return nfserrno(len);
> > +
> > + if (*buflen < ((XDR_QUADLEN(len) << 2) + 4 + 4 + 4)) {
> > + err = nfserr_resource;
> > + goto out;
> > + }
> > +
> > + /* XXX: A call to the translation code should be placed here
> > + * for now send 0 until we have that to indicate the null
> > + * translation */
> > +
> > + if ((*buflen -= 4) < 0)
> > + return nfserr_resource;
> > +
> > + WRITE32(lfs);
> > + WRITE32(pi);
> > + p = xdr_encode_opaque(p, context, len);
> > + *buflen -= (XDR_QUADLEN(len) << 2) + 4;
> > +
> > + *pp = p;
> > +out:
> > + security_release_secctx(context, len);
> > + return err;
> > +}
> > +#else
> > +static inline __be32
> > +nfsd4_encode_security_label(struct svc_rqst *rqstp, struct dentry *dentry, __be32 **pp, int *buflen)
> > +{ return 0; }
> > +#endif
> > +
> > static __be32 fattr_handle_absent_fs(u32 *bmval0, u32 *bmval1, u32 *rdattr_err)
> > {
> > /* As per referral draft: */
> > @@ -2111,6 +2205,10 @@ nfsd4_encode_fattr(struct svc_fh *fhp, struct svc_export *exp,
> >
> > if (!aclsupport)
> > word0 &= ~FATTR4_WORD0_ACL;
> > +#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
> > + if (word2)
> > + word2 |= FATTR4_WORD2_SECURITY_LABEL;
> > +#endif
>
> Please just fix the definition of NFSD4_1_SUPPORTED_ATTRS_WORD2. (The
> ifdef can go in that definition.)
>
> Although: don't we need to check whether the exported filesystem
> supports security labels?
>
> > if (!word2) {
> > if ((buflen -= 12) < 0)
> > goto out_resource;
> > @@ -2423,6 +2521,14 @@ out_acl:
> > get_parent_attributes(exp, &stat);
> > WRITE64(stat.ino);
> > }
> > + if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) {
> > + status = nfsd4_encode_security_label(rqstp, dentry,
> > + &p, &buflen);
> > + if (status == nfserr_resource)
> > + goto out_resource;
>
> Just remove that, there's no real point to the out_resource goto.
>
> > + if (status)
> > + goto out;
>
> > + }
> > if (bmval2 & FATTR4_WORD2_SUPPATTR_EXCLCREAT) {
> > WRITE32(3);
> > WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD0);
> > diff --git a/fs/nfsd/nfsd.h b/fs/nfsd/nfsd.h
> > index de23db2..727fe44 100644
> > --- a/fs/nfsd/nfsd.h
> > +++ b/fs/nfsd/nfsd.h
> > @@ -308,10 +308,10 @@ void nfsd_lockd_shutdown(void);
> > | FATTR4_WORD1_OWNER | FATTR4_WORD1_OWNER_GROUP | FATTR4_WORD1_RAWDEV \
> > | FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE | FATTR4_WORD1_SPACE_TOTAL \
> > | FATTR4_WORD1_SPACE_USED | FATTR4_WORD1_TIME_ACCESS | FATTR4_WORD1_TIME_ACCESS_SET \
> > - | FATTR4_WORD1_TIME_DELTA | FATTR4_WORD1_TIME_METADATA \
> > - | FATTR4_WORD1_TIME_MODIFY | FATTR4_WORD1_TIME_MODIFY_SET | FATTR4_WORD1_MOUNTED_ON_FILEID)
> > + | FATTR4_WORD1_TIME_DELTA | FATTR4_WORD1_TIME_METADATA | FATTR4_WORD1_TIME_MODIFY \
> > + | FATTR4_WORD1_TIME_MODIFY_SET | FATTR4_WORD1_MOUNTED_ON_FILEID)
>
> Did that actually change anything? If not, just leave the formatting
> alone.
>
> >
> > -#define NFSD4_SUPPORTED_ATTRS_WORD2 0
> > +#define NFSD4_SUPPORTED_ATTRS_WORD2 FATTR4_WORD2_SECURITY_LABEL
>
> That should be conditional on CONFIG_NFSD_V4_SECURITY_LABEL, shouldn't
> it?
>
> >
> > #define NFSD4_1_SUPPORTED_ATTRS_WORD0 \
> > NFSD4_SUPPORTED_ATTRS_WORD0
> > @@ -350,7 +350,7 @@ static inline u32 nfsd_suppattrs2(u32 minorversion)
> > #define NFSD_WRITEABLE_ATTRS_WORD1 \
> > (FATTR4_WORD1_MODE | FATTR4_WORD1_OWNER | FATTR4_WORD1_OWNER_GROUP \
> > | FATTR4_WORD1_TIME_ACCESS_SET | FATTR4_WORD1_TIME_MODIFY_SET)
> > -#define NFSD_WRITEABLE_ATTRS_WORD2 0
> > +#define NFSD_WRITEABLE_ATTRS_WORD2 FATTR4_WORD2_SECURITY_LABEL
> >
> > #define NFSD_SUPPATTR_EXCLCREAT_WORD0 \
> > NFSD_WRITEABLE_ATTRS_WORD0
> > diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
> > index d586117..0567fdc 100644
> > --- a/fs/nfsd/vfs.c
> > +++ b/fs/nfsd/vfs.c
> > @@ -28,6 +28,7 @@
> > #include <asm/uaccess.h>
> > #include <linux/exportfs.h>
> > #include <linux/writeback.h>
> > +#include <linux/security.h>
> >
> > #ifdef CONFIG_NFSD_V3
> > #include "xdr3.h"
> > @@ -621,6 +622,35 @@ int nfsd4_is_junction(struct dentry *dentry)
> > return 0;
> > return 1;
> > }
> > +#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
> > +__be32 nfsd4_set_nfs4_label(struct svc_rqst *rqstp, struct svc_fh *fhp,
> > + struct nfs4_label *label)
> > +{
> > + __be32 error;
> > + int host_error;
> > + struct dentry *dentry;
> > +
> > + /* Get inode */
>
> That comment's unnecessary.
>
> > + /* XXX: should we have a MAY_SSECCTX? */
>
> I don't know, should we?
>
> --b.
>
> > + error = fh_verify(rqstp, fhp, 0 /* S_IFREG */, NFSD_MAY_SATTR);
> > + if (error)
> > + return error;
> > +
> > + dentry = fhp->fh_dentry;
> > +
> > + mutex_lock(&dentry->d_inode->i_mutex);
> > + host_error = security_inode_setsecctx(dentry, label->label, label->len);
> > + mutex_unlock(&dentry->d_inode->i_mutex);
> > + return nfserrno(host_error);
> > +}
> > +#else
> > +__be32 nfsd4_set_nfs4_label(struct svc_rqst *rqstp, struct svc_fh *fhp,
> > + struct nfs4_label *label)
> > +{
> > + return -EOPNOTSUPP;
> > +}
> > +#endif
> > +
> > #endif /* defined(CONFIG_NFSD_V4) */
> >
> > #ifdef CONFIG_NFSD_V3
> > diff --git a/fs/nfsd/vfs.h b/fs/nfsd/vfs.h
> > index 359594c..49c6cc0 100644
> > --- a/fs/nfsd/vfs.h
> > +++ b/fs/nfsd/vfs.h
> > @@ -55,6 +55,8 @@ int nfsd_mountpoint(struct dentry *, struct svc_export *);
> > __be32 nfsd4_set_nfs4_acl(struct svc_rqst *, struct svc_fh *,
> > struct nfs4_acl *);
> > int nfsd4_get_nfs4_acl(struct svc_rqst *, struct dentry *, struct nfs4_acl **);
> > +__be32 nfsd4_set_nfs4_label(struct svc_rqst *, struct svc_fh *,
> > + struct nfs4_label *);
> > #endif /* CONFIG_NFSD_V4 */
> > __be32 nfsd_create(struct svc_rqst *, struct svc_fh *,
> > char *name, int len, struct iattr *attrs,
> > diff --git a/fs/nfsd/xdr4.h b/fs/nfsd/xdr4.h
> > index 0889bfb..9e7e663 100644
> > --- a/fs/nfsd/xdr4.h
> > +++ b/fs/nfsd/xdr4.h
> > @@ -118,6 +118,7 @@ struct nfsd4_create {
> > struct iattr cr_iattr; /* request */
> > struct nfsd4_change_info cr_cinfo; /* response */
> > struct nfs4_acl *cr_acl;
> > + struct nfs4_label *cr_label;
> > };
> > #define cr_linklen u.link.namelen
> > #define cr_linkname u.link.name
> > @@ -246,6 +247,7 @@ struct nfsd4_open {
> > struct nfs4_file *op_file; /* used during processing */
> > struct nfs4_ol_stateid *op_stp; /* used during processing */
> > struct nfs4_acl *op_acl;
> > + struct nfs4_label *op_label;
> > };
> > #define op_iattr iattr
> >
> > @@ -330,6 +332,7 @@ struct nfsd4_setattr {
> > u32 sa_bmval[3]; /* request */
> > struct iattr sa_iattr; /* request */
> > struct nfs4_acl *sa_acl;
> > + struct nfs4_label *sa_label;
> > };
> >
> > struct nfsd4_setclientid {
> > --
> > 1.7.11.7
> >
> > --
> > To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
> > the body of a message to majordomo@vger.kernel.org
> > More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 00/15] lnfs: 3.8-rc6 release
2013-02-08 12:39 ` Steve Dickson
` (16 preceding siblings ...)
(?)
@ 2013-02-12 23:11 ` J. Bruce Fields
[not found] ` <20130212231113.GQ10267-uC3wQj2KruNg9hUCZPvPmw@public.gmane.org>
-1 siblings, 1 reply; 58+ messages in thread
From: J. Bruce Fields @ 2013-02-12 23:11 UTC (permalink / raw)
To: Steve Dickson
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
So originally I thought Dave was saying we'd try to get the label change
attribute in the initial submission. I guess it'll be coming later
instead?
This is going to be a part of NFSv4.2, so shouldn't this really come
with patches to implement minor version 2? (Should be totally trivial
as it doesn't have to do anything other than labeled NFS for now.)
If not, that's another reason why we don't want to recommend building
this by default. Though maybe advertising labeled NFS support in v4.1
won't cause a problem for any implementation in practice, I don't know.
--b.
^ permalink raw reply [flat|nested] 58+ messages in thread
* RE: [PATCH 00/15] lnfs: 3.8-rc6 release
2013-02-12 23:11 ` J. Bruce Fields
@ 2013-02-12 23:18 ` Myklebust, Trond
0 siblings, 0 replies; 58+ messages in thread
From: Myklebust, Trond @ 2013-02-12 23:18 UTC (permalink / raw)
To: J. Bruce Fields, Steve Dickson
Cc: J. Bruce Fields, David P. Quigley, Linux NFS list,
Linux FS devel list, Linux Security List, SELinux List
We definitely do need a 4.2 minor version label. As you said, that shouldn't be hard since 4.2 is basically 4.1 with new enhancements, and we already have all the minorversion machinery ready and working.
> -----Original Message-----
> From: J. Bruce Fields [mailto:bfields-uC3wQj2KruNg9hUCZPvPmw@public.gmane.org]
> Sent: Tuesday, February 12, 2013 6:11 PM
> To: Steve Dickson
> Cc: Myklebust, Trond; J. Bruce Fields; David P. Quigley; Linux NFS list; Linux FS
> devel list; Linux Security List; SELinux List
> Subject: Re: [PATCH 00/15] lnfs: 3.8-rc6 release
>
> So originally I thought Dave was saying we'd try to get the label change
> attribute in the initial submission. I guess it'll be coming later instead?
>
> This is going to be a part of NFSv4.2, so shouldn't this really come with
> patches to implement minor version 2? (Should be totally trivial as it doesn't
> have to do anything other than labeled NFS for now.)
>
> If not, that's another reason why we don't want to recommend building this
> by default. Though maybe advertising labeled NFS support in v4.1 won't
> cause a problem for any implementation in practice, I don't know.
>
> --b.
--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 58+ messages in thread
* RE: [PATCH 00/15] lnfs: 3.8-rc6 release
@ 2013-02-12 23:18 ` Myklebust, Trond
0 siblings, 0 replies; 58+ messages in thread
From: Myklebust, Trond @ 2013-02-12 23:18 UTC (permalink / raw)
To: J. Bruce Fields, Steve Dickson
Cc: J. Bruce Fields, David P. Quigley, Linux NFS list,
Linux FS devel list, Linux Security List, SELinux List
We definitely do need a 4.2 minor version label. As you said, that shouldn't be hard since 4.2 is basically 4.1 with new enhancements, and we already have all the minorversion machinery ready and working.
> -----Original Message-----
> From: J. Bruce Fields [mailto:bfields@fieldses.org]
> Sent: Tuesday, February 12, 2013 6:11 PM
> To: Steve Dickson
> Cc: Myklebust, Trond; J. Bruce Fields; David P. Quigley; Linux NFS list; Linux FS
> devel list; Linux Security List; SELinux List
> Subject: Re: [PATCH 00/15] lnfs: 3.8-rc6 release
>
> So originally I thought Dave was saying we'd try to get the label change
> attribute in the initial submission. I guess it'll be coming later instead?
>
> This is going to be a part of NFSv4.2, so shouldn't this really come with
> patches to implement minor version 2? (Should be totally trivial as it doesn't
> have to do anything other than labeled NFS for now.)
>
> If not, that's another reason why we don't want to recommend building this
> by default. Though maybe advertising labeled NFS support in v4.1 won't
> cause a problem for any implementation in practice, I don't know.
>
> --b.
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 00/15] lnfs: 3.8-rc6 release
2013-02-08 12:39 ` Steve Dickson
` (17 preceding siblings ...)
(?)
@ 2013-02-13 0:11 ` J. Bruce Fields
2013-02-13 0:21 ` J. Bruce Fields
-1 siblings, 1 reply; 58+ messages in thread
From: J. Bruce Fields @ 2013-02-13 0:11 UTC (permalink / raw)
To: Steve Dickson
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
I get failures on NFSv4 mounts after applying these patches.
# mount -tnfs4 pip1:/exports/ext4 /mnt/
mount.nfs4: mounting pip1:/exports/ext4 failed, reason given by server: No such file or directory
In wireshark I don't see an error, but I do notice that the final
rpc request and reply is a getattr with bitmap 0, which is odd.
--b.
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 00/15] lnfs: 3.8-rc6 release
2013-02-13 0:11 ` J. Bruce Fields
@ 2013-02-13 0:21 ` J. Bruce Fields
2013-02-13 0:28 ` Steve Dickson
0 siblings, 1 reply; 58+ messages in thread
From: J. Bruce Fields @ 2013-02-13 0:21 UTC (permalink / raw)
To: Steve Dickson
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On Tue, Feb 12, 2013 at 07:11:41PM -0500, J. Bruce Fields wrote:
> I get failures on NFSv4 mounts after applying these patches.
>
> # mount -tnfs4 pip1:/exports/ext4 /mnt/
> mount.nfs4: mounting pip1:/exports/ext4 failed, reason given by server: No such file or directory
>
> In wireshark I don't see an error, but I do notice that the final
> rpc request and reply is a getattr with bitmap 0, which is odd.
Oh, and that was a build with labeled nfs configured out.
--b.
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 00/15] lnfs: 3.8-rc6 release
2013-02-13 0:21 ` J. Bruce Fields
@ 2013-02-13 0:28 ` Steve Dickson
2013-02-13 15:05 ` J. Bruce Fields
0 siblings, 1 reply; 58+ messages in thread
From: Steve Dickson @ 2013-02-13 0:28 UTC (permalink / raw)
To: J. Bruce Fields
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On 12/02/13 19:21, J. Bruce Fields wrote:
> On Tue, Feb 12, 2013 at 07:11:41PM -0500, J. Bruce Fields wrote:
>> I get failures on NFSv4 mounts after applying these patches.
>>
>> # mount -tnfs4 pip1:/exports/ext4 /mnt/
>> mount.nfs4: mounting pip1:/exports/ext4 failed, reason given by server: No such file or directory
>>
>> In wireshark I don't see an error, but I do notice that the final
>> rpc request and reply is a getattr with bitmap 0, which is odd.
>
> Oh, and that was a build with labeled nfs configured out.
Drop the -tnfs4 option... I think it has something to do with breaking up the version into
modules... I never investigated why that worked...
steved.
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 06/15] NFSv4: Introduce new label structure
2013-02-12 23:06 ` J. Bruce Fields
@ 2013-02-13 0:30 ` Steve Dickson
0 siblings, 0 replies; 58+ messages in thread
From: Steve Dickson @ 2013-02-13 0:30 UTC (permalink / raw)
To: J. Bruce Fields
Cc: Myklebust, Trond, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On 12/02/13 18:06, J. Bruce Fields wrote:
> On Tue, Feb 12, 2013 at 10:40:46PM +0000, Myklebust, Trond wrote:
>> On Tue, 2013-02-12 at 17:32 -0500, J. Bruce Fields wrote:
>>> On Tue, Feb 12, 2013 at 10:28:16PM +0000, Myklebust, Trond wrote:
>>>> On Tue, 2013-02-12 at 17:07 -0500, J. Bruce Fields wrote:
>>>>> On Fri, Feb 08, 2013 at 07:39:14AM -0500, Steve Dickson wrote:
>>>>>> From: David Quigley <dpquigl@davequigley.com>
>>>>>>
>>>>>> In order to mimic the way that NFSv4 ACLs are implemented we have created a
>>>>>> structure to be used to pass label data up and down the call chain. This patch
>>>>>> adds the new structure and new members to the required NFSv4 call structures.
>>>>>>
>>>>>> Signed-off-by: Matthew N. Dodd <Matthew.Dodd@sparta.com>
>>>>>> Signed-off-by: Miguel Rodel Felipe <Rodel_FM@dsi.a-star.edu.sg>
>>>>>> Signed-off-by: Phua Eu Gene <PHUA_Eu_Gene@dsi.a-star.edu.sg>
>>>>>> Signed-off-by: Khin Mi Mi Aung <Mi_Mi_AUNG@dsi.a-star.edu.sg>
>>>>>> ---
>>>>>> fs/nfs/inode.c | 33 +++++++++++++++++++++++++++++++++
>>>>>> include/linux/nfs4.h | 7 +++++++
>>>>>> include/linux/nfs_fs.h | 17 +++++++++++++++++
>>>>>> include/linux/nfs_xdr.h | 21 +++++++++++++++++++++
>>>>>> include/uapi/linux/nfs4.h | 2 +-
>>>>>> 5 files changed, 79 insertions(+), 1 deletion(-)
>>>>>>
>>>>>> diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
>>>>>> index ebeb94c..8d5f01b 100644
>>>>>> --- a/fs/nfs/inode.c
>>>>>> +++ b/fs/nfs/inode.c
>>>>>> @@ -255,6 +255,39 @@ nfs_init_locked(struct inode *inode, void *opaque)
>>>>>> return 0;
>>>>>> }
>>>>>>
>>>>>> +#ifdef CONFIG_NFS_V4_SECURITY_LABEL
>>>>>> +struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags)
>>>>>> +{
>>>>>> + struct nfs4_label *label = NULL;
>>>>>> +
>>>>>> + if (!(server->caps & NFS_CAP_SECURITY_LABEL))
>>>>>> + return label;
>>>>>> +
>>>>>> + label = kzalloc(NFS4_MAXLABELLEN, flags);
>>>>>> + if (label == NULL)
>>>>>> + return ERR_PTR(-ENOMEM);
>>>>>> +
>>>>>> + label->label = (char *)(label + 1);
>>>>>> + label->len = NFS4_MAXLABELLEN;
>>>>>
>>>>> If you're expecting to be able to store up to NFS4_MAXLABELLEN of data
>>>>> after the end of the struct, then you want:
>>>>>
>>>>> label = kzalloc(sizeof(struct nfs4_label) + NFS4_MAXLABELLEN, flags);
>>>>
>>>> Sigh... No.
>>>>
>>>> I keep telling Steve that the 'label' needs to be defined as an array,
>>>
>>> Yeah, I know, he said in 0/15 that he couldn't do that, so I've been
>>> reading through these on the assumption I'll find out why not at some
>>> point.... (Still not seeing it, though.)
>>
>> It only makes sense to define label->label as a pointer if you need to
>> change the pointer value at some time. However, if that is the case,
>> then why allocate the struct nfs4_label and label string as a single
>> memory block? It would make more sense to allocate them separately so
>> that you can free the old label storage after you change the pointer.
>
> nfs4_get_security_label() in a later patch is indeed using some
> passed-in storage instead, but I'm not sure it's doing it correctly.
Exactly, this is the interface where I'm thinking it makes sense to
keep label->label a pointer.
steved.
>
> It would seem simpler to pick either inline or separate storage and
> stick with it throughout.
>
> I'd be inclined to favor inline even if it means larger allocations than
> necessary or an extra copy. Just because it seems harder to mess up.
>
> --b.
>
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 00/15] lnfs: 3.8-rc6 release
2013-02-12 22:02 ` Casey Schaufler
(?)
(?)
@ 2013-02-13 0:32 ` Steve Dickson
2013-02-13 0:55 ` Casey Schaufler
-1 siblings, 1 reply; 58+ messages in thread
From: Steve Dickson @ 2013-02-13 0:32 UTC (permalink / raw)
To: Casey Schaufler
Cc: J. Bruce Fields, Trond Myklebust, J. Bruce Fields,
David P. Quigley, Linux NFS list, Linux FS devel list,
Linux Security List, SELinux List
On 12/02/13 17:02, Casey Schaufler wrote:
> On 2/12/2013 1:41 PM, J. Bruce Fields wrote:
>> On Fri, Feb 08, 2013 at 07:39:08AM -0500, Steve Dickson wrote:
>>> include/linux/security.h | 57 +++-
>> ...
>>> security/capability.c | 19 +-
>>> security/security.c | 24 +-
>>> security/selinux/hooks.c | 92 +++++-
>>> security/selinux/include/security.h | 2 +
>>> security/selinux/ss/policydb.c | 5 +-
>>> security/smack/smack_lsm.c | 11 +
>>> 33 files changed, 1352 insertions(+), 214 deletions(-)
>> Are we still waiting on ACKs from the security people for these bits?
>
> I'm not going to NAK it, because I don't know it won't work,
> but I'm not going to ACK it either, because I have not been
> able to get it to work. I have no idea what the problem
> might be, and the "obvious" things we've tried have proven
> ineffective. I may have a bad set of user space tools. There
> may be more work on Smack hooks required. I can't tell, and
> there's way too much NFS set-up involved to make progress in
> the limited time I have available.
Would you please give me an example of what you have not gotten to work?
steved.
>
> If you're waiting for my ACK, no, you don't have it.
> If you're OK with a lack of NAK, go ahead. There will
> be changes someday I suspect, but I can't put this high
> enough on my priorities to devote the time required
> just now.
>
>>
>> --b.
>> --
>> To unsubscribe from this list: send the line "unsubscribe linux-security-module" in
>> the body of a message to majordomo@vger.kernel.org
>> More majordomo info at http://vger.kernel.org/majordomo-info.html
>>
>
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 00/15] lnfs: 3.8-rc6 release
2013-02-13 0:32 ` Steve Dickson
@ 2013-02-13 0:55 ` Casey Schaufler
0 siblings, 0 replies; 58+ messages in thread
From: Casey Schaufler @ 2013-02-13 0:55 UTC (permalink / raw)
To: Steve Dickson
Cc: J. Bruce Fields, Trond Myklebust, J. Bruce Fields,
David P. Quigley, Linux NFS list, Linux FS devel list,
Linux Security List, SELinux List, Casey Schaufler
On 2/12/2013 4:32 PM, Steve Dickson wrote:
>
> On 12/02/13 17:02, Casey Schaufler wrote:
>> On 2/12/2013 1:41 PM, J. Bruce Fields wrote:
>>> On Fri, Feb 08, 2013 at 07:39:08AM -0500, Steve Dickson wrote:
>>>> include/linux/security.h | 57 +++-
>>> ...
>>>> security/capability.c | 19 +-
>>>> security/security.c | 24 +-
>>>> security/selinux/hooks.c | 92 +++++-
>>>> security/selinux/include/security.h | 2 +
>>>> security/selinux/ss/policydb.c | 5 +-
>>>> security/smack/smack_lsm.c | 11 +
>>>> 33 files changed, 1352 insertions(+), 214 deletions(-)
>>> Are we still waiting on ACKs from the security people for these bits?
>> I'm not going to NAK it, because I don't know it won't work,
>> but I'm not going to ACK it either, because I have not been
>> able to get it to work. I have no idea what the problem
>> might be, and the "obvious" things we've tried have proven
>> ineffective. I may have a bad set of user space tools. There
>> may be more work on Smack hooks required. I can't tell, and
>> there's way too much NFS set-up involved to make progress in
>> the limited time I have available.
> Would you please give me an example of what you have not gotten to work?
I am the maintainer of the Smack LSM. These patches do
not result in a system that passes Smack labels. I have
put some effort into tracking down why this is the case,
but have not yet been successful. The early theory that
the kernel server thread was not running with sufficient
privilege turned out to be a red herring. At this point
we don't know what the problem(s) is and more digging
will be required.
>
> steved.
>
>> If you're waiting for my ACK, no, you don't have it.
>> If you're OK with a lack of NAK, go ahead. There will
>> be changes someday I suspect, but I can't put this high
>> enough on my priorities to devote the time required
>> just now.
>>
>>> --b.
>>> --
>>> To unsubscribe from this list: send the line "unsubscribe linux-security-module" in
>>> the body of a message to majordomo@vger.kernel.org
>>> More majordomo info at http://vger.kernel.org/majordomo-info.html
>>>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-security-module" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
>
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 00/15] lnfs: 3.8-rc6 release
@ 2013-02-13 0:55 ` Casey Schaufler
0 siblings, 0 replies; 58+ messages in thread
From: Casey Schaufler @ 2013-02-13 0:55 UTC (permalink / raw)
To: Steve Dickson
Cc: J. Bruce Fields, Trond Myklebust, J. Bruce Fields,
David P. Quigley, Linux NFS list, Linux FS devel list,
Linux Security List, SELinux List, Casey Schaufler
On 2/12/2013 4:32 PM, Steve Dickson wrote:
>
> On 12/02/13 17:02, Casey Schaufler wrote:
>> On 2/12/2013 1:41 PM, J. Bruce Fields wrote:
>>> On Fri, Feb 08, 2013 at 07:39:08AM -0500, Steve Dickson wrote:
>>>> include/linux/security.h | 57 +++-
>>> ...
>>>> security/capability.c | 19 +-
>>>> security/security.c | 24 +-
>>>> security/selinux/hooks.c | 92 +++++-
>>>> security/selinux/include/security.h | 2 +
>>>> security/selinux/ss/policydb.c | 5 +-
>>>> security/smack/smack_lsm.c | 11 +
>>>> 33 files changed, 1352 insertions(+), 214 deletions(-)
>>> Are we still waiting on ACKs from the security people for these bits?
>> I'm not going to NAK it, because I don't know it won't work,
>> but I'm not going to ACK it either, because I have not been
>> able to get it to work. I have no idea what the problem
>> might be, and the "obvious" things we've tried have proven
>> ineffective. I may have a bad set of user space tools. There
>> may be more work on Smack hooks required. I can't tell, and
>> there's way too much NFS set-up involved to make progress in
>> the limited time I have available.
> Would you please give me an example of what you have not gotten to work?
I am the maintainer of the Smack LSM. These patches do
not result in a system that passes Smack labels. I have
put some effort into tracking down why this is the case,
but have not yet been successful. The early theory that
the kernel server thread was not running with sufficient
privilege turned out to be a red herring. At this point
we don't know what the problem(s) is and more digging
will be required.
>
> steved.
>
>> If you're waiting for my ACK, no, you don't have it.
>> If you're OK with a lack of NAK, go ahead. There will
>> be changes someday I suspect, but I can't put this high
>> enough on my priorities to devote the time required
>> just now.
>>
>>> --b.
>>> --
>>> To unsubscribe from this list: send the line "unsubscribe linux-security-module" in
>>> the body of a message to majordomo@vger.kernel.org
>>> More majordomo info at http://vger.kernel.org/majordomo-info.html
>>>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-security-module" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
>
--
This message was distributed to subscribers of the selinux mailing list.
If you no longer wish to subscribe, send mail to majordomo@tycho.nsa.gov with
the words "unsubscribe selinux" without quotes as the message.
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 00/15] lnfs: 3.8-rc6 release
2013-02-13 0:28 ` Steve Dickson
@ 2013-02-13 15:05 ` J. Bruce Fields
2013-02-13 15:33 ` J. Bruce Fields
0 siblings, 1 reply; 58+ messages in thread
From: J. Bruce Fields @ 2013-02-13 15:05 UTC (permalink / raw)
To: Steve Dickson
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On Tue, Feb 12, 2013 at 07:28:49PM -0500, Steve Dickson wrote:
>
>
> On 12/02/13 19:21, J. Bruce Fields wrote:
> > On Tue, Feb 12, 2013 at 07:11:41PM -0500, J. Bruce Fields wrote:
> >> I get failures on NFSv4 mounts after applying these patches.
> >>
> >> # mount -tnfs4 pip1:/exports/ext4 /mnt/
> >> mount.nfs4: mounting pip1:/exports/ext4 failed, reason given by server: No such file or directory
> >>
> >> In wireshark I don't see an error, but I do notice that the final
> >> rpc request and reply is a getattr with bitmap 0, which is odd.
> >
> > Oh, and that was a build with labeled nfs configured out.
> Drop the -tnfs4 option...
Well, sure, then it'll negotiate down to v3 and the mount will succeed.
But if you request v4 (either with -tnfs4 or -onfsvers=4), it fails.
In other words, these patches break NFSv4 mounts in the default
(CONFIG_NFS_V4_SECURITY_LABEL=n) case.
--b.
> I think it has something to do with breaking up the version into
> modules... I never investigated why that worked...
>
> steved.
>
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 12/15] lnfs: Do not sleep holding the inode spin lock
2013-02-08 12:39 ` [PATCH 12/15] lnfs: Do not sleep holding the inode spin lock Steve Dickson
@ 2013-02-13 15:16 ` J. Bruce Fields
0 siblings, 0 replies; 58+ messages in thread
From: J. Bruce Fields @ 2013-02-13 15:16 UTC (permalink / raw)
To: Steve Dickson
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On Fri, Feb 08, 2013 at 07:39:20AM -0500, Steve Dickson wrote:
> From: Dave Quigley <dpquigl-gOTzo9bHY9kXsfPmpmaFlNaxn9tAw+E3@public.gmane.org>
>
> The nfs_setsecurity code can sleep while allocating memory
> so the inode spin lock can not be held while during this call.
If this is the right fix, it needs to be folded into patch 10/15, where
the problem was introduced.
--b.
>
> Signed-off-by: Steve Dickson <steved-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org>
> ---
> fs/nfs/inode.c | 10 +++++++---
> 1 file changed, 7 insertions(+), 3 deletions(-)
>
> diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
> index 0d412c4..65bf9ca 100644
> --- a/fs/nfs/inode.c
> +++ b/fs/nfs/inode.c
> @@ -1285,6 +1285,9 @@ int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr, struct nfs4_
> status = nfs_refresh_inode_locked(inode, fattr, label);
> spin_unlock(&inode->i_lock);
>
> + if (label && !status)
> + nfs_setsecurity(inode, fattr, label);
> +
> return status;
> }
> EXPORT_SYMBOL_GPL(nfs_refresh_inode);
> @@ -1324,6 +1327,10 @@ int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr, struc
> spin_lock(&inode->i_lock);
> status = nfs_post_op_update_inode_locked(inode, fattr, label);
> spin_unlock(&inode->i_lock);
> + if (nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL)) {
> + if (label && !status)
> + nfs_setsecurity(inode, fattr, label);
> + }
> return status;
> }
> EXPORT_SYMBOL_GPL(nfs_post_op_update_inode);
> @@ -1543,9 +1550,6 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr, struct
> | NFS_INO_INVALID_ACL
> | NFS_INO_REVAL_FORCED);
>
> - if (label && (server->caps & NFS_CAP_SECURITY_LABEL))
> - nfs_setsecurity(inode, fattr, label);
> -
> if (fattr->valid & NFS_ATTR_FATTR_NLINK) {
> if (inode->i_nlink != fattr->nlink) {
> invalid |= NFS_INO_INVALID_ATTR;
> --
> 1.7.11.7
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
> the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 12/15] lnfs: Do not sleep holding the inode spin lock
@ 2013-02-13 15:16 ` J. Bruce Fields
0 siblings, 0 replies; 58+ messages in thread
From: J. Bruce Fields @ 2013-02-13 15:16 UTC (permalink / raw)
To: Steve Dickson
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On Fri, Feb 08, 2013 at 07:39:20AM -0500, Steve Dickson wrote:
> From: Dave Quigley <dpquigl@taiga.selinuxproject.org>
>
> The nfs_setsecurity code can sleep while allocating memory
> so the inode spin lock can not be held while during this call.
If this is the right fix, it needs to be folded into patch 10/15, where
the problem was introduced.
--b.
>
> Signed-off-by: Steve Dickson <steved@redhat.com>
> ---
> fs/nfs/inode.c | 10 +++++++---
> 1 file changed, 7 insertions(+), 3 deletions(-)
>
> diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
> index 0d412c4..65bf9ca 100644
> --- a/fs/nfs/inode.c
> +++ b/fs/nfs/inode.c
> @@ -1285,6 +1285,9 @@ int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr, struct nfs4_
> status = nfs_refresh_inode_locked(inode, fattr, label);
> spin_unlock(&inode->i_lock);
>
> + if (label && !status)
> + nfs_setsecurity(inode, fattr, label);
> +
> return status;
> }
> EXPORT_SYMBOL_GPL(nfs_refresh_inode);
> @@ -1324,6 +1327,10 @@ int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr, struc
> spin_lock(&inode->i_lock);
> status = nfs_post_op_update_inode_locked(inode, fattr, label);
> spin_unlock(&inode->i_lock);
> + if (nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL)) {
> + if (label && !status)
> + nfs_setsecurity(inode, fattr, label);
> + }
> return status;
> }
> EXPORT_SYMBOL_GPL(nfs_post_op_update_inode);
> @@ -1543,9 +1550,6 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr, struct
> | NFS_INO_INVALID_ACL
> | NFS_INO_REVAL_FORCED);
>
> - if (label && (server->caps & NFS_CAP_SECURITY_LABEL))
> - nfs_setsecurity(inode, fattr, label);
> -
> if (fattr->valid & NFS_ATTR_FATTR_NLINK) {
> if (inode->i_nlink != fattr->nlink) {
> invalid |= NFS_INO_INVALID_ATTR;
> --
> 1.7.11.7
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 00/15] lnfs: 3.8-rc6 release
2013-02-13 15:05 ` J. Bruce Fields
@ 2013-02-13 15:33 ` J. Bruce Fields
0 siblings, 0 replies; 58+ messages in thread
From: J. Bruce Fields @ 2013-02-13 15:33 UTC (permalink / raw)
To: Steve Dickson
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On Wed, Feb 13, 2013 at 10:05:09AM -0500, J. Bruce Fields wrote:
> On Tue, Feb 12, 2013 at 07:28:49PM -0500, Steve Dickson wrote:
> >
> >
> > On 12/02/13 19:21, J. Bruce Fields wrote:
> > > On Tue, Feb 12, 2013 at 07:11:41PM -0500, J. Bruce Fields wrote:
> > >> I get failures on NFSv4 mounts after applying these patches.
> > >>
> > >> # mount -tnfs4 pip1:/exports/ext4 /mnt/
> > >> mount.nfs4: mounting pip1:/exports/ext4 failed, reason given by server: No such file or directory
> > >>
> > >> In wireshark I don't see an error, but I do notice that the final
> > >> rpc request and reply is a getattr with bitmap 0, which is odd.
> > >
> > > Oh, and that was a build with labeled nfs configured out.
> > Drop the -tnfs4 option...
>
> Well, sure, then it'll negotiate down to v3 and the mount will succeed.
>
> But if you request v4 (either with -tnfs4 or -onfsvers=4), it fails.
>
> In other words, these patches break NFSv4 mounts in the default
> (CONFIG_NFS_V4_SECURITY_LABEL=n) case.
Also, the problem starts with "NFS: Client Implementation of
Labeled-NFS".
--b.
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 09/15] NFS: Add label lifecycle management
2013-02-12 22:27 ` J. Bruce Fields
@ 2013-02-16 20:28 ` Steve Dickson
0 siblings, 0 replies; 58+ messages in thread
From: Steve Dickson @ 2013-02-16 20:28 UTC (permalink / raw)
To: J. Bruce Fields
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On 12/02/13 17:27, J. Bruce Fields wrote:
>> @@ -2922,6 +2969,7 @@ static int _nfs4_proc_remove(struct inode *dir, struct qstr *name)
>> > status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1);
>> > if (status == 0)
>> > update_changeattr(dir, &res.cinfo);
>> > +
>> > return status;
>> > }
>> >
>> > @@ -2965,6 +3013,7 @@ static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir)
>> > if (nfs4_async_handle_error(task, res->server, NULL) == -EAGAIN)
>> > return 0;
>> > update_changeattr(dir, &res->cinfo);
>> > +
>> > return 1;
>> > }
>> >
> How'd these two hunks end up in here?
I have no idea.. but they are gone..
steved.
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 10/15] NFS: Client implementation of Labeled-NFS
2013-02-12 23:03 ` J. Bruce Fields
@ 2013-02-16 20:35 ` Steve Dickson
[not found] ` <511FED8E.7020308-AfCzQyP5zfLQT0dZR+AlfA@public.gmane.org>
0 siblings, 1 reply; 58+ messages in thread
From: Steve Dickson @ 2013-02-16 20:35 UTC (permalink / raw)
To: J. Bruce Fields
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On 12/02/13 18:03, J. Bruce Fields wrote:
>> +static int decode_attr_security_label(struct xdr_stream *xdr, uint32_t *bitmap,
>> > + struct nfs4_label *label)
>> > +{
>> > + uint32_t pi = 0;
>> > + uint32_t lfs = 0;
>> > + __u32 len;
>> > + __be32 *p;
>> > + int status = 0;
>> > +
>> > + if (unlikely(bitmap[2] & (FATTR4_WORD2_SECURITY_LABEL - 1U)))
>> > + return -EIO;
>> > + if (likely(bitmap[2] & FATTR4_WORD2_SECURITY_LABEL)) {
>> > + p = xdr_inline_decode(xdr, 4);
>> > + if (unlikely(!p))
>> > + goto out_overflow;
>> > + lfs = be32_to_cpup(p++);
>> > + p = xdr_inline_decode(xdr, 4);
>> > + if (unlikely(!p))
>> > + goto out_overflow;
>> > + pi = be32_to_cpup(p++);
>> > + p = xdr_inline_decode(xdr, 4);
>> > + if (unlikely(!p))
>> > + goto out_overflow;
>> > + len = be32_to_cpup(p++);
>> > + p = xdr_inline_decode(xdr, len);
>> > + if (unlikely(!p))
>> > + goto out_overflow;
>> > + if (len < XDR_MAX_NETOBJ) {
>> > + if (label) {
>> > + nfs4_label_init(label);
>> > + if (label->len < len) {
> If I remember the earlier patch right, nfs4_label_init() just set
> label->len to NFS4_MAXLABELLEN.
Good good catch... XDR_MAX_NETOBJ should be NFS4_MAXLABELLEN.
>
> Doesn't that overwrite the length that was passed into
> nfs4_get_security_label?
Yes... the len will be set to the actual size of the label which
will be less than NFS4_MAXLABELLEN. So I'm thinking this overwrite
of the is fine.
This is the reason nfs4_label_init() resets len to NFS4_MAXLABELLEN
steved.
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 12/15] lnfs: Do not sleep holding the inode spin lock
2013-02-13 15:16 ` J. Bruce Fields
@ 2013-02-16 20:36 ` Steve Dickson
-1 siblings, 0 replies; 58+ messages in thread
From: Steve Dickson @ 2013-02-16 20:36 UTC (permalink / raw)
To: J. Bruce Fields
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On 13/02/13 10:16, J. Bruce Fields wrote:
> On Fri, Feb 08, 2013 at 07:39:20AM -0500, Steve Dickson wrote:
>> > From: Dave Quigley <dpquigl-gOTzo9bHY9kXsfPmpmaFlNaxn9tAw+E3@public.gmane.org>
>> >
>> > The nfs_setsecurity code can sleep while allocating memory
>> > so the inode spin lock can not be held while during this call.
> If this is the right fix, it needs to be folded into patch 10/15, where
> the problem was introduced.
Gone!
steved.
--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 12/15] lnfs: Do not sleep holding the inode spin lock
@ 2013-02-16 20:36 ` Steve Dickson
0 siblings, 0 replies; 58+ messages in thread
From: Steve Dickson @ 2013-02-16 20:36 UTC (permalink / raw)
To: J. Bruce Fields
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On 13/02/13 10:16, J. Bruce Fields wrote:
> On Fri, Feb 08, 2013 at 07:39:20AM -0500, Steve Dickson wrote:
>> > From: Dave Quigley <dpquigl@taiga.selinuxproject.org>
>> >
>> > The nfs_setsecurity code can sleep while allocating memory
>> > so the inode spin lock can not be held while during this call.
> If this is the right fix, it needs to be folded into patch 10/15, where
> the problem was introduced.
Gone!
steved.
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 14/15] NFSD: Server implementation of MAC Labeling
2013-02-12 22:54 ` J. Bruce Fields
@ 2013-02-16 20:44 ` Steve Dickson
[not found] ` <20130212225425.GM10267-uC3wQj2KruNg9hUCZPvPmw@public.gmane.org>
1 sibling, 0 replies; 58+ messages in thread
From: Steve Dickson @ 2013-02-16 20:44 UTC (permalink / raw)
To: J. Bruce Fields
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On 12/02/13 17:54, J. Bruce Fields wrote:
> On Fri, Feb 08, 2013 at 07:39:22AM -0500, Steve Dickson wrote:
>> @@ -242,7 +247,8 @@ nfsd4_decode_bitmap(struct nfsd4_compoundargs *argp, u32 *bmval)
>>
>> static __be32
>> nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval,
>> - struct iattr *iattr, struct nfs4_acl **acl)
>> + struct iattr *iattr, struct nfs4_acl **acl,
>> + struct nfs4_label **label)
>> {
>> int expected_len, len = 0;
>> u32 dummy32;
>> @@ -386,6 +392,50 @@ nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval,
>> goto xdr_error;
>> }
>> }
>> +#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
>> + if (bmval[2] & FATTR4_WORD2_SECURITY_LABEL) {
>> + uint32_t pi;
>> + uint32_t lfs;
>> +
>> + READ_BUF(4);
>> + len += 4;
>> + READ32(lfs);
>> + READ_BUF(4);
>> + len += 4;
>> + READ32(pi);
>> + READ_BUF(4);
>> + len += 4;
>> + READ32(dummy32);
>> + READ_BUF(dummy32);
>> + len += (XDR_QUADLEN(dummy32) << 2);
>> + READMEM(buf, dummy32);
>> +
>> + if (dummy32 > NFS4_MAXLABELLEN)
>> + return nfserr_resource;
>> +
>> + *label = kzalloc(sizeof(struct nfs4_label), GFP_KERNEL);
>
> So we don't want to allocate these the same way we did on the client?
These allocations are slightly different.. One is for incoming labels
and the other is for out going...
>
>> + if (*label == NULL) {
>> + host_err = -ENOMEM;
>> + goto out_nfserr;
>> + }
>> +
>> + (*label)->label = kmalloc(dummy32 + 1, GFP_KERNEL);
>> + if ((*label)->label == NULL) {
>> + host_err = -ENOMEM;
>> + kfree(*label);
>> + goto out_nfserr;
>> + }
>> +
>> + (*label)->len = dummy32;
>> + memcpy((*label)->label, buf, dummy32);
>> + ((char *)(*label)->label)[dummy32] = '\0';
>> + (*label)->pi = pi;
>> + (*label)->lfs = lfs;
>> +
>> + defer_free(argp, kfree, (*label)->label);
>> + defer_free(argp, kfree, *label);
>
> Hm: looking at defer_free and nfsd4_release_compoundargs: looks like
> argp->to_free is effectively a stack, so these will get freed in the
> reverse order: *label first, then (*label)->label. That's trouble.
>
> So, I think we want the order of those two defer_free()'s reversed.
>
> Or we could just allocate the whole things as one chunk as on the client
> and not have to worry about this kind of thing. I think I'd prefer that
> to trying to keep the allocation as small as possible. We're only using
> this memory temporarily so it's not as though we need to have tons of
> struct nfs4_labels allocated at the same time anyway.
I reworked this in the upcoming release to be more chunky... ;-)
>> +
>> static __be32 fattr_handle_absent_fs(u32 *bmval0, u32 *bmval1, u32 *rdattr_err)
>> {
>> /* As per referral draft: */
>> @@ -2111,6 +2205,10 @@ nfsd4_encode_fattr(struct svc_fh *fhp, struct svc_export *exp,
>>
>> if (!aclsupport)
>> word0 &= ~FATTR4_WORD0_ACL;
>> +#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
>> + if (word2)
>> + word2 |= FATTR4_WORD2_SECURITY_LABEL;
>> +#endif
>
> Please just fix the definition of NFSD4_1_SUPPORTED_ATTRS_WORD2. (The
> ifdef can go in that definition.)
Right...
>
> Although: don't we need to check whether the exported filesystem
> supports security labels?
I took a quick look around and didn't see any interface to do that.
Is it even possible to do this?
>
>> if (!word2) {
>> if ((buflen -= 12) < 0)
>> goto out_resource;
>> @@ -2423,6 +2521,14 @@ out_acl:
>> get_parent_attributes(exp, &stat);
>> WRITE64(stat.ino);
>> }
>> + if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) {
>> + status = nfsd4_encode_security_label(rqstp, dentry,
>> + &p, &buflen);
>> + if (status == nfserr_resource)
>> + goto out_resource;
>
> Just remove that, there's no real point to the out_resource goto.
Gone...
>
>> + if (status)
>> + goto out;
>
>> + }
>> if (bmval2 & FATTR4_WORD2_SUPPATTR_EXCLCREAT) {
>> WRITE32(3);
>> WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD0);
>> diff --git a/fs/nfsd/nfsd.h b/fs/nfsd/nfsd.h
>> index de23db2..727fe44 100644
>> --- a/fs/nfsd/nfsd.h
>> +++ b/fs/nfsd/nfsd.h
>> @@ -308,10 +308,10 @@ void nfsd_lockd_shutdown(void);
>> | FATTR4_WORD1_OWNER | FATTR4_WORD1_OWNER_GROUP | FATTR4_WORD1_RAWDEV \
>> | FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE | FATTR4_WORD1_SPACE_TOTAL \
>> | FATTR4_WORD1_SPACE_USED | FATTR4_WORD1_TIME_ACCESS | FATTR4_WORD1_TIME_ACCESS_SET \
>> - | FATTR4_WORD1_TIME_DELTA | FATTR4_WORD1_TIME_METADATA \
>> - | FATTR4_WORD1_TIME_MODIFY | FATTR4_WORD1_TIME_MODIFY_SET | FATTR4_WORD1_MOUNTED_ON_FILEID)
>> + | FATTR4_WORD1_TIME_DELTA | FATTR4_WORD1_TIME_METADATA | FATTR4_WORD1_TIME_MODIFY \
>> + | FATTR4_WORD1_TIME_MODIFY_SET | FATTR4_WORD1_MOUNTED_ON_FILEID)
>
> Did that actually change anything? If not, just leave the formatting
> alone.
Gone...
>
>>
>> -#define NFSD4_SUPPORTED_ATTRS_WORD2 0
>> +#define NFSD4_SUPPORTED_ATTRS_WORD2 FATTR4_WORD2_SECURITY_LABEL
>
> That should be conditional on CONFIG_NFSD_V4_SECURITY_LABEL, shouldn't
> it?
Yes..
>
>>
>> #define NFSD4_1_SUPPORTED_ATTRS_WORD0 \
>> NFSD4_SUPPORTED_ATTRS_WORD0
>> @@ -350,7 +350,7 @@ static inline u32 nfsd_suppattrs2(u32 minorversion)
>> #define NFSD_WRITEABLE_ATTRS_WORD1 \
>> (FATTR4_WORD1_MODE | FATTR4_WORD1_OWNER | FATTR4_WORD1_OWNER_GROUP \
>> | FATTR4_WORD1_TIME_ACCESS_SET | FATTR4_WORD1_TIME_MODIFY_SET)
>> -#define NFSD_WRITEABLE_ATTRS_WORD2 0
>> +#define NFSD_WRITEABLE_ATTRS_WORD2 FATTR4_WORD2_SECURITY_LABEL
>>
>> #define NFSD_SUPPATTR_EXCLCREAT_WORD0 \
>> NFSD_WRITEABLE_ATTRS_WORD0
>> diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
>> index d586117..0567fdc 100644
>> --- a/fs/nfsd/vfs.c
>> +++ b/fs/nfsd/vfs.c
>> @@ -28,6 +28,7 @@
>> #include <asm/uaccess.h>
>> #include <linux/exportfs.h>
>> #include <linux/writeback.h>
>> +#include <linux/security.h>
>>
>> #ifdef CONFIG_NFSD_V3
>> #include "xdr3.h"
>> @@ -621,6 +622,35 @@ int nfsd4_is_junction(struct dentry *dentry)
>> return 0;
>> return 1;
>> }
>> +#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
>> +__be32 nfsd4_set_nfs4_label(struct svc_rqst *rqstp, struct svc_fh *fhp,
>> + struct nfs4_label *label)
>> +{
>> + __be32 error;
>> + int host_error;
>> + struct dentry *dentry;
>> +
>> + /* Get inode */
>
> That comment's unnecessary.
Gone...
>
>> + /* XXX: should we have a MAY_SSECCTX? */
>
> I don't know, should we?
I vote no! ;-) What is that?
steved.
--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 14/15] NFSD: Server implementation of MAC Labeling
@ 2013-02-16 20:44 ` Steve Dickson
0 siblings, 0 replies; 58+ messages in thread
From: Steve Dickson @ 2013-02-16 20:44 UTC (permalink / raw)
To: J. Bruce Fields
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On 12/02/13 17:54, J. Bruce Fields wrote:
> On Fri, Feb 08, 2013 at 07:39:22AM -0500, Steve Dickson wrote:
>> @@ -242,7 +247,8 @@ nfsd4_decode_bitmap(struct nfsd4_compoundargs *argp, u32 *bmval)
>>
>> static __be32
>> nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval,
>> - struct iattr *iattr, struct nfs4_acl **acl)
>> + struct iattr *iattr, struct nfs4_acl **acl,
>> + struct nfs4_label **label)
>> {
>> int expected_len, len = 0;
>> u32 dummy32;
>> @@ -386,6 +392,50 @@ nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval,
>> goto xdr_error;
>> }
>> }
>> +#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
>> + if (bmval[2] & FATTR4_WORD2_SECURITY_LABEL) {
>> + uint32_t pi;
>> + uint32_t lfs;
>> +
>> + READ_BUF(4);
>> + len += 4;
>> + READ32(lfs);
>> + READ_BUF(4);
>> + len += 4;
>> + READ32(pi);
>> + READ_BUF(4);
>> + len += 4;
>> + READ32(dummy32);
>> + READ_BUF(dummy32);
>> + len += (XDR_QUADLEN(dummy32) << 2);
>> + READMEM(buf, dummy32);
>> +
>> + if (dummy32 > NFS4_MAXLABELLEN)
>> + return nfserr_resource;
>> +
>> + *label = kzalloc(sizeof(struct nfs4_label), GFP_KERNEL);
>
> So we don't want to allocate these the same way we did on the client?
These allocations are slightly different.. One is for incoming labels
and the other is for out going...
>
>> + if (*label == NULL) {
>> + host_err = -ENOMEM;
>> + goto out_nfserr;
>> + }
>> +
>> + (*label)->label = kmalloc(dummy32 + 1, GFP_KERNEL);
>> + if ((*label)->label == NULL) {
>> + host_err = -ENOMEM;
>> + kfree(*label);
>> + goto out_nfserr;
>> + }
>> +
>> + (*label)->len = dummy32;
>> + memcpy((*label)->label, buf, dummy32);
>> + ((char *)(*label)->label)[dummy32] = '\0';
>> + (*label)->pi = pi;
>> + (*label)->lfs = lfs;
>> +
>> + defer_free(argp, kfree, (*label)->label);
>> + defer_free(argp, kfree, *label);
>
> Hm: looking at defer_free and nfsd4_release_compoundargs: looks like
> argp->to_free is effectively a stack, so these will get freed in the
> reverse order: *label first, then (*label)->label. That's trouble.
>
> So, I think we want the order of those two defer_free()'s reversed.
>
> Or we could just allocate the whole things as one chunk as on the client
> and not have to worry about this kind of thing. I think I'd prefer that
> to trying to keep the allocation as small as possible. We're only using
> this memory temporarily so it's not as though we need to have tons of
> struct nfs4_labels allocated at the same time anyway.
I reworked this in the upcoming release to be more chunky... ;-)
>> +
>> static __be32 fattr_handle_absent_fs(u32 *bmval0, u32 *bmval1, u32 *rdattr_err)
>> {
>> /* As per referral draft: */
>> @@ -2111,6 +2205,10 @@ nfsd4_encode_fattr(struct svc_fh *fhp, struct svc_export *exp,
>>
>> if (!aclsupport)
>> word0 &= ~FATTR4_WORD0_ACL;
>> +#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
>> + if (word2)
>> + word2 |= FATTR4_WORD2_SECURITY_LABEL;
>> +#endif
>
> Please just fix the definition of NFSD4_1_SUPPORTED_ATTRS_WORD2. (The
> ifdef can go in that definition.)
Right...
>
> Although: don't we need to check whether the exported filesystem
> supports security labels?
I took a quick look around and didn't see any interface to do that.
Is it even possible to do this?
>
>> if (!word2) {
>> if ((buflen -= 12) < 0)
>> goto out_resource;
>> @@ -2423,6 +2521,14 @@ out_acl:
>> get_parent_attributes(exp, &stat);
>> WRITE64(stat.ino);
>> }
>> + if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) {
>> + status = nfsd4_encode_security_label(rqstp, dentry,
>> + &p, &buflen);
>> + if (status == nfserr_resource)
>> + goto out_resource;
>
> Just remove that, there's no real point to the out_resource goto.
Gone...
>
>> + if (status)
>> + goto out;
>
>> + }
>> if (bmval2 & FATTR4_WORD2_SUPPATTR_EXCLCREAT) {
>> WRITE32(3);
>> WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD0);
>> diff --git a/fs/nfsd/nfsd.h b/fs/nfsd/nfsd.h
>> index de23db2..727fe44 100644
>> --- a/fs/nfsd/nfsd.h
>> +++ b/fs/nfsd/nfsd.h
>> @@ -308,10 +308,10 @@ void nfsd_lockd_shutdown(void);
>> | FATTR4_WORD1_OWNER | FATTR4_WORD1_OWNER_GROUP | FATTR4_WORD1_RAWDEV \
>> | FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE | FATTR4_WORD1_SPACE_TOTAL \
>> | FATTR4_WORD1_SPACE_USED | FATTR4_WORD1_TIME_ACCESS | FATTR4_WORD1_TIME_ACCESS_SET \
>> - | FATTR4_WORD1_TIME_DELTA | FATTR4_WORD1_TIME_METADATA \
>> - | FATTR4_WORD1_TIME_MODIFY | FATTR4_WORD1_TIME_MODIFY_SET | FATTR4_WORD1_MOUNTED_ON_FILEID)
>> + | FATTR4_WORD1_TIME_DELTA | FATTR4_WORD1_TIME_METADATA | FATTR4_WORD1_TIME_MODIFY \
>> + | FATTR4_WORD1_TIME_MODIFY_SET | FATTR4_WORD1_MOUNTED_ON_FILEID)
>
> Did that actually change anything? If not, just leave the formatting
> alone.
Gone...
>
>>
>> -#define NFSD4_SUPPORTED_ATTRS_WORD2 0
>> +#define NFSD4_SUPPORTED_ATTRS_WORD2 FATTR4_WORD2_SECURITY_LABEL
>
> That should be conditional on CONFIG_NFSD_V4_SECURITY_LABEL, shouldn't
> it?
Yes..
>
>>
>> #define NFSD4_1_SUPPORTED_ATTRS_WORD0 \
>> NFSD4_SUPPORTED_ATTRS_WORD0
>> @@ -350,7 +350,7 @@ static inline u32 nfsd_suppattrs2(u32 minorversion)
>> #define NFSD_WRITEABLE_ATTRS_WORD1 \
>> (FATTR4_WORD1_MODE | FATTR4_WORD1_OWNER | FATTR4_WORD1_OWNER_GROUP \
>> | FATTR4_WORD1_TIME_ACCESS_SET | FATTR4_WORD1_TIME_MODIFY_SET)
>> -#define NFSD_WRITEABLE_ATTRS_WORD2 0
>> +#define NFSD_WRITEABLE_ATTRS_WORD2 FATTR4_WORD2_SECURITY_LABEL
>>
>> #define NFSD_SUPPATTR_EXCLCREAT_WORD0 \
>> NFSD_WRITEABLE_ATTRS_WORD0
>> diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
>> index d586117..0567fdc 100644
>> --- a/fs/nfsd/vfs.c
>> +++ b/fs/nfsd/vfs.c
>> @@ -28,6 +28,7 @@
>> #include <asm/uaccess.h>
>> #include <linux/exportfs.h>
>> #include <linux/writeback.h>
>> +#include <linux/security.h>
>>
>> #ifdef CONFIG_NFSD_V3
>> #include "xdr3.h"
>> @@ -621,6 +622,35 @@ int nfsd4_is_junction(struct dentry *dentry)
>> return 0;
>> return 1;
>> }
>> +#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
>> +__be32 nfsd4_set_nfs4_label(struct svc_rqst *rqstp, struct svc_fh *fhp,
>> + struct nfs4_label *label)
>> +{
>> + __be32 error;
>> + int host_error;
>> + struct dentry *dentry;
>> +
>> + /* Get inode */
>
> That comment's unnecessary.
Gone...
>
>> + /* XXX: should we have a MAY_SSECCTX? */
>
> I don't know, should we?
I vote no! ;-) What is that?
steved.
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 10/15] NFS: Client implementation of Labeled-NFS
2013-02-16 20:35 ` Steve Dickson
@ 2013-02-16 22:30 ` J. Bruce Fields
0 siblings, 0 replies; 58+ messages in thread
From: J. Bruce Fields @ 2013-02-16 22:30 UTC (permalink / raw)
To: Steve Dickson
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On Sat, Feb 16, 2013 at 03:35:26PM -0500, Steve Dickson wrote:
> On 12/02/13 18:03, J. Bruce Fields wrote:
> >> +static int decode_attr_security_label(struct xdr_stream *xdr, uint32_t *bitmap,
> >> > + struct nfs4_label *label)
> >> > +{
> >> > + uint32_t pi = 0;
> >> > + uint32_t lfs = 0;
> >> > + __u32 len;
> >> > + __be32 *p;
> >> > + int status = 0;
> >> > +
> >> > + if (unlikely(bitmap[2] & (FATTR4_WORD2_SECURITY_LABEL - 1U)))
> >> > + return -EIO;
> >> > + if (likely(bitmap[2] & FATTR4_WORD2_SECURITY_LABEL)) {
> >> > + p = xdr_inline_decode(xdr, 4);
> >> > + if (unlikely(!p))
> >> > + goto out_overflow;
> >> > + lfs = be32_to_cpup(p++);
> >> > + p = xdr_inline_decode(xdr, 4);
> >> > + if (unlikely(!p))
> >> > + goto out_overflow;
> >> > + pi = be32_to_cpup(p++);
> >> > + p = xdr_inline_decode(xdr, 4);
> >> > + if (unlikely(!p))
> >> > + goto out_overflow;
> >> > + len = be32_to_cpup(p++);
> >> > + p = xdr_inline_decode(xdr, len);
> >> > + if (unlikely(!p))
> >> > + goto out_overflow;
> >> > + if (len < XDR_MAX_NETOBJ) {
> >> > + if (label) {
> >> > + nfs4_label_init(label);
> >> > + if (label->len < len) {
> > If I remember the earlier patch right, nfs4_label_init() just set
> > label->len to NFS4_MAXLABELLEN.
> Good good catch... XDR_MAX_NETOBJ should be NFS4_MAXLABELLEN.
>
> >
> > Doesn't that overwrite the length that was passed into
> > nfs4_get_security_label?
> Yes... the len will be set to the actual size of the label which
> will be less than NFS4_MAXLABELLEN. So I'm thinking this overwrite
> of the is fine.
>
> This is the reason nfs4_label_init() resets len to NFS4_MAXLABELLEN
OK, but then
if (label->len < len)
is equivalent to
if (NFS4_MAXLABELLEN < len)
Why are we checking len twice?
You may want to just remove nfs4_label_init() entirely. This is the
only caller, and it doesn't seem very useful.
--b.
--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 10/15] NFS: Client implementation of Labeled-NFS
@ 2013-02-16 22:30 ` J. Bruce Fields
0 siblings, 0 replies; 58+ messages in thread
From: J. Bruce Fields @ 2013-02-16 22:30 UTC (permalink / raw)
To: Steve Dickson
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On Sat, Feb 16, 2013 at 03:35:26PM -0500, Steve Dickson wrote:
> On 12/02/13 18:03, J. Bruce Fields wrote:
> >> +static int decode_attr_security_label(struct xdr_stream *xdr, uint32_t *bitmap,
> >> > + struct nfs4_label *label)
> >> > +{
> >> > + uint32_t pi = 0;
> >> > + uint32_t lfs = 0;
> >> > + __u32 len;
> >> > + __be32 *p;
> >> > + int status = 0;
> >> > +
> >> > + if (unlikely(bitmap[2] & (FATTR4_WORD2_SECURITY_LABEL - 1U)))
> >> > + return -EIO;
> >> > + if (likely(bitmap[2] & FATTR4_WORD2_SECURITY_LABEL)) {
> >> > + p = xdr_inline_decode(xdr, 4);
> >> > + if (unlikely(!p))
> >> > + goto out_overflow;
> >> > + lfs = be32_to_cpup(p++);
> >> > + p = xdr_inline_decode(xdr, 4);
> >> > + if (unlikely(!p))
> >> > + goto out_overflow;
> >> > + pi = be32_to_cpup(p++);
> >> > + p = xdr_inline_decode(xdr, 4);
> >> > + if (unlikely(!p))
> >> > + goto out_overflow;
> >> > + len = be32_to_cpup(p++);
> >> > + p = xdr_inline_decode(xdr, len);
> >> > + if (unlikely(!p))
> >> > + goto out_overflow;
> >> > + if (len < XDR_MAX_NETOBJ) {
> >> > + if (label) {
> >> > + nfs4_label_init(label);
> >> > + if (label->len < len) {
> > If I remember the earlier patch right, nfs4_label_init() just set
> > label->len to NFS4_MAXLABELLEN.
> Good good catch... XDR_MAX_NETOBJ should be NFS4_MAXLABELLEN.
>
> >
> > Doesn't that overwrite the length that was passed into
> > nfs4_get_security_label?
> Yes... the len will be set to the actual size of the label which
> will be less than NFS4_MAXLABELLEN. So I'm thinking this overwrite
> of the is fine.
>
> This is the reason nfs4_label_init() resets len to NFS4_MAXLABELLEN
OK, but then
if (label->len < len)
is equivalent to
if (NFS4_MAXLABELLEN < len)
Why are we checking len twice?
You may want to just remove nfs4_label_init() entirely. This is the
only caller, and it doesn't seem very useful.
--b.
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 14/15] NFSD: Server implementation of MAC Labeling
2013-02-16 20:44 ` Steve Dickson
@ 2013-02-16 22:34 ` J. Bruce Fields
-1 siblings, 0 replies; 58+ messages in thread
From: J. Bruce Fields @ 2013-02-16 22:34 UTC (permalink / raw)
To: Steve Dickson
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On Sat, Feb 16, 2013 at 03:44:59PM -0500, Steve Dickson wrote:
> On 12/02/13 17:54, J. Bruce Fields wrote:
> >
> > Although: don't we need to check whether the exported filesystem
> > supports security labels?
> I took a quick look around and didn't see any interface to do that.
> Is it even possible to do this?
Try fetching a security label and check whether the response is
EOPNOTSUPP, I think. That's what the ACL code does.
> >> + /* XXX: should we have a MAY_SSECCTX? */
> >
> > I don't know, should we?
> I vote no! ;-) What is that?
Maybe this is a question for Dave--who wrote that comment? How should
we be checking for permissions to set the security label?
--b.
--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 14/15] NFSD: Server implementation of MAC Labeling
@ 2013-02-16 22:34 ` J. Bruce Fields
0 siblings, 0 replies; 58+ messages in thread
From: J. Bruce Fields @ 2013-02-16 22:34 UTC (permalink / raw)
To: Steve Dickson
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On Sat, Feb 16, 2013 at 03:44:59PM -0500, Steve Dickson wrote:
> On 12/02/13 17:54, J. Bruce Fields wrote:
> >
> > Although: don't we need to check whether the exported filesystem
> > supports security labels?
> I took a quick look around and didn't see any interface to do that.
> Is it even possible to do this?
Try fetching a security label and check whether the response is
EOPNOTSUPP, I think. That's what the ACL code does.
> >> + /* XXX: should we have a MAY_SSECCTX? */
> >
> > I don't know, should we?
> I vote no! ;-) What is that?
Maybe this is a question for Dave--who wrote that comment? How should
we be checking for permissions to set the security label?
--b.
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 10/15] NFS: Client implementation of Labeled-NFS
2013-02-16 22:30 ` J. Bruce Fields
(?)
@ 2013-02-17 1:24 ` Steve Dickson
2013-02-17 1:47 ` Steve Dickson
-1 siblings, 1 reply; 58+ messages in thread
From: Steve Dickson @ 2013-02-17 1:24 UTC (permalink / raw)
To: J. Bruce Fields
Cc: Trond Myklebust, J. Bruce Fields, David P. Quigley,
Linux NFS list, Linux FS devel list, Linux Security List,
SELinux List
On 16/02/13 17:30, J. Bruce Fields wrote:
> On Sat, Feb 16, 2013 at 03:35:26PM -0500, Steve Dickson wrote:
>> On 12/02/13 18:03, J. Bruce Fields wrote:
>>>> +static int decode_attr_security_label(struct xdr_stream *xdr, uint32_t *bitmap,
>>>>> + struct nfs4_label *label)
>>>>> +{
>>>>> + uint32_t pi = 0;
>>>>> + uint32_t lfs = 0;
>>>>> + __u32 len;
>>>>> + __be32 *p;
>>>>> + int status = 0;
>>>>> +
>>>>> + if (unlikely(bitmap[2] & (FATTR4_WORD2_SECURITY_LABEL - 1U)))
>>>>> + return -EIO;
>>>>> + if (likely(bitmap[2] & FATTR4_WORD2_SECURITY_LABEL)) {
>>>>> + p = xdr_inline_decode(xdr, 4);
>>>>> + if (unlikely(!p))
>>>>> + goto out_overflow;
>>>>> + lfs = be32_to_cpup(p++);
>>>>> + p = xdr_inline_decode(xdr, 4);
>>>>> + if (unlikely(!p))
>>>>> + goto out_overflow;
>>>>> + pi = be32_to_cpup(p++);
>>>>> + p = xdr_inline_decode(xdr, 4);
>>>>> + if (unlikely(!p))
>>>>> + goto out_overflow;
>>>>> + len = be32_to_cpup(p++);
>>>>> + p = xdr_inline_decode(xdr, len);
>>>>> + if (unlikely(!p))
>>>>> + goto out_overflow;
>>>>> + if (len < XDR_MAX_NETOBJ) {
>>>>> + if (label) {
>>>>> + nfs4_label_init(label);
>>>>> + if (label->len < len) {
>>> If I remember the earlier patch right, nfs4_label_init() just set
>>> label->len to NFS4_MAXLABELLEN.
>> Good good catch... XDR_MAX_NETOBJ should be NFS4_MAXLABELLEN.
>>
>>>
>>> Doesn't that overwrite the length that was passed into
>>> nfs4_get_security_label?
>> Yes... the len will be set to the actual size of the label which
>> will be less than NFS4_MAXLABELLEN. So I'm thinking this overwrite
>> of the is fine.
>>
>> This is the reason nfs4_label_init() resets len to NFS4_MAXLABELLEN
>
> OK, but then
> if (label->len < len)
> is equivalent to
> if (NFS4_MAXLABELLEN < len)
> Why are we checking len twice?
I see your point...
>
> You may want to just remove nfs4_label_init() entirely. This is the
> only caller, and it doesn't seem very useful.
Its a useful way to reset len back to NFS4_MAXLABELLEN as well as
lfs and pi back to zero...
steved.
^ permalink raw reply [flat|nested] 58+ messages in thread
* Re: [PATCH 10/15] NFS: Client implementation of Labeled-NFS
2013-02-17 1:24 ` Steve Dickson
@ 2013-02-17 1:47 ` Steve Dickson
0 siblings, 0 replies; 58+ messages in thread
From: Steve Dickson @ 2013-02-17 1:47 UTC (permalink / raw)
To: Steve Dickson
Cc: J. Bruce Fields, Trond Myklebust, J. Bruce Fields,
David P. Quigley, Linux NFS list, Linux FS devel list,
Linux Security List, SELinux List
On 16/02/13 20:24, Steve Dickson wrote:
>> > You may want to just remove nfs4_label_init() entirely. This is the
>> > only caller, and it doesn't seem very useful.
> Its a useful way to reset len back to NFS4_MAXLABELLEN as well as
> lfs and pi back to zero...
On second thought... It is useless... I'll remove it...
steved.
^ permalink raw reply [flat|nested] 58+ messages in thread
end of thread, other threads:[~2013-02-17 1:48 UTC | newest]
Thread overview: 58+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2013-02-08 12:39 [PATCH 00/15] lnfs: 3.8-rc6 release Steve Dickson
2013-02-08 12:39 ` Steve Dickson
2013-02-08 12:39 ` [PATCH 01/15] Security: Add hook to calculate context based on a negative dentry Steve Dickson
2013-02-08 12:39 ` [PATCH 02/15] Security: Add Hook to test if the particular xattr is part of a MAC model Steve Dickson
2013-02-08 12:39 ` [PATCH 03/15] LSM: Add flags field to security_sb_set_mnt_opts for in kernel mount data Steve Dickson
2013-02-08 12:39 ` [PATCH 04/15] SELinux: Add new labeling type native labels Steve Dickson
2013-02-08 12:39 ` [PATCH 05/15] NFSv4: Add label recommended attribute and NFSv4 flags Steve Dickson
2013-02-08 12:39 ` [PATCH 06/15] NFSv4: Introduce new label structure Steve Dickson
2013-02-12 22:07 ` J. Bruce Fields
[not found] ` <20130212220741.GJ10267-uC3wQj2KruNg9hUCZPvPmw@public.gmane.org>
2013-02-12 22:28 ` Myklebust, Trond
2013-02-12 22:28 ` Myklebust, Trond
2013-02-12 22:32 ` J. Bruce Fields
2013-02-12 22:40 ` Myklebust, Trond
2013-02-12 23:06 ` J. Bruce Fields
2013-02-13 0:30 ` Steve Dickson
2013-02-08 12:39 ` [PATCH 07/15] NFSv4: Extend fattr bitmaps to support all 3 words Steve Dickson
2013-02-08 12:39 ` [PATCH 08/15] NFS:Add labels to client function prototypes Steve Dickson
2013-02-08 12:39 ` [PATCH 09/15] NFS: Add label lifecycle management Steve Dickson
2013-02-12 22:27 ` J. Bruce Fields
2013-02-16 20:28 ` Steve Dickson
[not found] ` <1360327163-20360-1-git-send-email-SteveD-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org>
2013-02-08 12:39 ` [PATCH 10/15] NFS: Client implementation of Labeled-NFS Steve Dickson
2013-02-08 12:39 ` Steve Dickson
2013-02-12 23:03 ` J. Bruce Fields
2013-02-16 20:35 ` Steve Dickson
[not found] ` <511FED8E.7020308-AfCzQyP5zfLQT0dZR+AlfA@public.gmane.org>
2013-02-16 22:30 ` J. Bruce Fields
2013-02-16 22:30 ` J. Bruce Fields
2013-02-17 1:24 ` Steve Dickson
2013-02-17 1:47 ` Steve Dickson
2013-02-08 12:39 ` [PATCH 11/15] NFS: Extend NFS xattr handlers to accept the security namespace Steve Dickson
2013-02-08 12:39 ` [PATCH 12/15] lnfs: Do not sleep holding the inode spin lock Steve Dickson
[not found] ` <1360327163-20360-13-git-send-email-SteveD-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org>
2013-02-13 15:16 ` J. Bruce Fields
2013-02-13 15:16 ` J. Bruce Fields
[not found] ` <20130213151610.GI14195-uC3wQj2KruNg9hUCZPvPmw@public.gmane.org>
2013-02-16 20:36 ` Steve Dickson
2013-02-16 20:36 ` Steve Dickson
2013-02-08 12:39 ` [PATCH 13/15] Kconfig: Add Kconfig entry for Labeled NFS V4 client Steve Dickson
2013-02-08 12:39 ` [PATCH 14/15] NFSD: Server implementation of MAC Labeling Steve Dickson
2013-02-12 22:54 ` J. Bruce Fields
2013-02-12 23:07 ` J. Bruce Fields
[not found] ` <20130212225425.GM10267-uC3wQj2KruNg9hUCZPvPmw@public.gmane.org>
2013-02-16 20:44 ` Steve Dickson
2013-02-16 20:44 ` Steve Dickson
[not found] ` <511FEFCB.2090002-AfCzQyP5zfLQT0dZR+AlfA@public.gmane.org>
2013-02-16 22:34 ` J. Bruce Fields
2013-02-16 22:34 ` J. Bruce Fields
2013-02-08 12:39 ` [PATCH 15/15] Kconfig: Add Kconfig entry for Labeled NFS V4 server Steve Dickson
2013-02-12 21:41 ` [PATCH 00/15] lnfs: 3.8-rc6 release J. Bruce Fields
2013-02-12 22:02 ` Casey Schaufler
2013-02-12 22:02 ` Casey Schaufler
2013-02-12 22:13 ` J. Bruce Fields
2013-02-13 0:32 ` Steve Dickson
2013-02-13 0:55 ` Casey Schaufler
2013-02-13 0:55 ` Casey Schaufler
2013-02-12 23:11 ` J. Bruce Fields
[not found] ` <20130212231113.GQ10267-uC3wQj2KruNg9hUCZPvPmw@public.gmane.org>
2013-02-12 23:18 ` Myklebust, Trond
2013-02-12 23:18 ` Myklebust, Trond
2013-02-13 0:11 ` J. Bruce Fields
2013-02-13 0:21 ` J. Bruce Fields
2013-02-13 0:28 ` Steve Dickson
2013-02-13 15:05 ` J. Bruce Fields
2013-02-13 15:33 ` J. Bruce Fields
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.