convert smack rule list to linux list
Subsystems (2)
PATCH 1/1 convert smack rule list to linux list
Hello,
this patch convert the smack_list list to standard linux list, struct smk_list_entry is also removed (list_head is added directly in smack_rule, smk_list_entry has no practical use?) this patch applies on top of
[PATCH][SMACK][RFC] convert smack_netlbladdrs to standard list
Please have a more detailed look at smk_write_load
I'm running witch smack enabled, everything that should be allowed is still allowed, everything that's should be denied is still denied, and i don't oops. :)
regards
Etienne
---
security/smack/smack.h +4 -12
@@ -59,18 +59,10 @@ struct inode_smack {* A label access rule. */ struct smack_rule { -char *smk_subject; -char *smk_object; -int smk_access; -}; - -/* -* An entry in the table of permitted label accesses. -*/ -struct smk_list_entry { -struct smk_list_entry *smk_next;struct list_head list; -struct smack_rule smk_rule; +char *smk_subject; +char *smk_object; +int smk_access; };/*
@@ -216,10 +208,10 @@ extern struct smack_known smack_known_invalid;extern struct smack_known smack_known_star;extern struct smack_known smack_known_web; -extern struct smk_list_entry *smack_list;extern struct list_head smack_know_list;extern struct list_head smack_rule_list;extern struct list_head smk_netlbladdr_list; +extern struct security_operations smack_ops;/*
security/smack/smack_access.c +2 -3
@@ -87,7 +87,6 @@ static u32 smack_next_secid = 10;int smk_access (char *subject_label,char *object_label,int request) {u32 may =MAY_NOT ; -struct smk_list_entry *sp;struct smack_rule *srp;/*
@@ -139,8 +138,8 @@ int smk_access(char *subject_label, char *object_label, int request)* access (e.g. read is included in readwrite) it's * good. */ -for (sp = smack_list; sp !=NULL ; sp = sp->smk_next) { - srp = &sp->smk_rule; + +list_for_each_entry (srp, &smack_rule_list, list) {if (srp->smk_subject == subject_label ||strcmp (srp->smk_subject, subject_label) ==0 ) {
security/smack/smackfs.c +50 -47
193 lines not on this page · raw message
Quoted 13 lines · etienne
security/smack/smack_access.c +0
-1@@ -87,7 +87,6 @@ static u32 smack_next_secid = 10;int smk_access (char *subject_label,char *object_label,int request) {u32 may =MAY_NOT ; -struct smk_list_entry *sp;struct smack_rule *srp;/*
security/smack/smack_access.c int smk_access(char *subject_label, char *object_label, int request) · line 145
Quoted 10 lines
security/smack/smack_access.c +2
-2@@ -139,8 +138,8 @@ int smk_access(char *subject_label, char *object_label, int request)* access (e.g. read is included in readwrite) it's * good. */ -for (sp = smack_list; sp !=NULL ; sp = sp->smk_next) { - srp = &sp->smk_rule; + +list_for_each_entry (srp, &smack_rule_list, list) {if (srp->smk_subject == subject_label ||strcmp (srp->smk_subject, subject_label) ==0 ) {
Use of standard doubly linked list requires a lock, doesn't it? What lock protects smack_rule_list?
Paul, would you review this locking?
Quoted 70 lines
static
DEFINE_MUTEX(smack_known_lock);/**
*smk_import_entry- import a label, return the list entry
* @string: a text string that might be a Smack label
* @len: the maximum size, or zero if it is NULL terminated. *
* Returns a pointer to the entry in the label list that
* matches the passed string, adding it if necessary. */
structsmack_known*smk_import_entry(const char *string, int len){ struct smack_known *skp; char smack[SMK_LABELLEN]; int found; int i; if (len <= 0 || len > SMK_MAXLEN) len = SMK_MAXLEN; for (i = 0, found = 0; i < SMK_LABELLEN; i++) { if (found) smack[i] = '\0'; else if (i >= len || string[i] > '~' || string[i] <= ' ' || string[i] == '/') { smack[i] = '\0'; found = 1; } else smack[i] = string[i]; } if (smack[0] == '\0') return NULL; mutex_lock(&smack_known_lock); for (skp = smack_known; skp != NULL; skp = skp->smk_next) if (strncmp(skp->smk_known, smack, SMK_MAXLEN) == 0) break; if (skp == NULL) { skp = kzalloc(sizeof(struct smack_known), GFP_KERNEL); if (skp != NULL) { skp->smk_next = smack_known; strncpy(skp->smk_known, smack, SMK_MAXLEN); skp->smk_secid = smack_next_secid++; skp->smk_cipso = NULL; spin_lock_init(&skp->smk_cipsolock); /* * Make sure that the entry is actually * filled before putting it on the list. */ smp_mb(); smack_known = skp; } } mutex_unlock(&smack_known_lock); return skp; }/**
*smack_from_secid- find the Smack label associated with a secid
* @secid: an integer that might be associated with a Smack label *
* Returns a pointer to the appropraite Smack label if there is one,
* otherwise a pointer to the invalid Smack label.
*/
char *smack_from_secid(const u32 secid)
Quoted 13 lines
{
struct smack_known *skp;
for (skp = smack_known; skp != NULL; skp = skp->smk_next)
if (skp->smk_secid == secid)
return skp->smk_known;
/*
* If we got this far someone asked for the translation
* of a secid that is not on the list.
*/
return smack_known_invalid.smk_known;
}I think this is a case called "dependency ordering". This function needs rcu_dereference(), doesn't it?
Regards.
Quoted 22 lines · Tetsuo Handa
Quoted 21 lines · etienne
security/smack/smack_access.c +2
-3@@ -87,7 +87,6 @@ static u32 smack_next_secid = 10;int smk_access (char *subject_label,char *object_label,int request) {u32 may =MAY_NOT ; -struct smk_list_entry *sp;struct smack_rule *srp;/* @@ -139,8 +138,8 @@ int smk_access(char *subject_label, char *object_label, int request)* access (e.g. read is included in readwrite) it's * good. */ -for (sp = smack_list; sp !=NULL ; sp = sp->smk_next) { - srp = &sp->smk_rule; + +list_for_each_entry (srp, &smack_rule_list, list) {
Quoted 6 lines
security/smack/smack_access.c int smk_access(char *subject_label, char *object_label, int request) · line 145
Quoted 2 lines
security/smack/smack_access.c +0
-0if (srp->smk_subject == subject_label ||strcmp (srp->smk_subject, subject_label) ==0 ) {Use of standard doubly linked list requires a lock, doesn't it? What lock protects
smack_rule_list?
you're right;
what's the best way, using a rcu variant for "list_for_each, container_of ...etc" ? (concurrent list insertion are already protected with a mutex, so rcu must the good idea for the read side)
thanks,
Etienne
Quoted 2 lines · etienne
what's the best way, using a rcu variant for "
list_for_each,container_of...etc" ? (concurrent list insertion are already protected with a mutex, so rcu must the good idea for the read side)
Read side will need a read lock.
I think you need to change from "mutex" to "rw_semaphore" (on the assumption that SMACK is safe against read locks that may sleep. If not, change from "mutex" to "rw_spinlock").
Regards.
Quoted 10 lines · Tetsuo Handa
Quoted 2 lines · etienne
what's the best way, using a rcu variant for "
list_for_each,container_of...etc" ? (concurrent list insertion are already protected with a mutex, so rcu must the good idea for the read side)Read side will need a read lock.
I think you need to change from "mutex" to "rw_semaphore" (on the assumption that SMACK is safe against read locks that may sleep. If not, change from "mutex" to "rw_spinlock").Regards.
or a rcu_read_lock?
since it disables preemption it means no user process will be able to change the list while it's read?
regards,
Etienne
Quoted 56 lines · Tetsuo Handa
Paul, would you review this locking?
Quoted 54 lines
static
DEFINE_MUTEX(smack_known_lock);/**
*smk_import_entry- import a label, return the list entry
* @string: a text string that might be a Smack label
* @len: the maximum size, or zero if it is NULL terminated. *
* Returns a pointer to the entry in the label list that
* matches the passed string, adding it if necessary. */
structsmack_known*smk_import_entry(const char *string, int len){ struct smack_known *skp; char smack[SMK_LABELLEN]; int found; int i; if (len <= 0 || len > SMK_MAXLEN) len = SMK_MAXLEN; for (i = 0, found = 0; i < SMK_LABELLEN; i++) { if (found) smack[i] = '\0'; else if (i >= len || string[i] > '~' || string[i] <= ' ' || string[i] == '/') { smack[i] = '\0'; found = 1; } else smack[i] = string[i]; } if (smack[0] == '\0') return NULL; mutex_lock(&smack_known_lock); for (skp = smack_known; skp != NULL; skp = skp->smk_next) if (strncmp(skp->smk_known, smack, SMK_MAXLEN) == 0) break; if (skp == NULL) { skp = kzalloc(sizeof(struct smack_known), GFP_KERNEL); if (skp != NULL) { skp->smk_next = smack_known; strncpy(skp->smk_known, smack, SMK_MAXLEN); skp->smk_secid = smack_next_secid++; skp->smk_cipso = NULL; spin_lock_init(&skp->smk_cipsolock); /* * Make sure that the entry is actually * filled before putting it on the list. */ smp_mb(); smack_known = skp;
If the read side is not acquiring smack_known_lock, then the above assignment to smack_known needs to be:
rcu_assign_pointer(smack_known, skp);
Otherwise, both CPU and compiler are within their rights to reorder the assignment to smack_known ahead of the initialization code.
Alternatively, if you make this list use a standard struct list_head, you could just use list_add_rcu().
Quoted 30 lines
Quoted 16 lines
} } mutex_unlock(&smack_known_lock); return skp; }/**
*smack_from_secid- find the Smack label associated with a secid
* @secid: an integer that might be associated with a Smack label *
* Returns a pointer to the appropraite Smack label if there is one,
* otherwise a pointer to the invalid Smack label.
*/
char *smack_from_secid(const u32 secid)Quoted 13 lines
{ struct smack_known *skp; for (skp = smack_known; skp != NULL; skp = skp->smk_next) if (skp->smk_secid == secid) return skp->smk_known; /* * If we got this far someone asked for the translation * of a secid that is not on the list. */ return smack_known_invalid.smk_known; }
Quoted 2 lines
I think this is a case called "dependency ordering". This function needs
rcu_dereference(), doesn't it?
Indeed! The "for" loop needs to be:
for (skp = rcu_dereference(smack_known); skp != NULL; skp = rcu_dereference(skp->smk_next))
Alternatively, if you switch to struct list_head, you could use list_for_each_entry_rcu().
There also need to be rcu_read_lock() and rcu_read_unlock() in here somewhere. Where they must be depends on how (or whether) you are ever removing any elements. If the string referenced by smk_known gets freed up, then the caller will need to surround the call to smack_from_secid() and the use of the return value with rcu_read_lock() and rcu_read_unlock(). Otherwise, only the smack_known structures are ever freed up, then just the "for" loop above needs to be so protected.
If these structure are never freed, then please add a comment.
Thanx, Paul
Quoted 29 lines · etienne
Quoted 22 lines · Tetsuo Handa
Quoted 21 lines · etienne
security/smack/smack_access.c +2
-3@@ -87,7 +87,6 @@ static u32 smack_next_secid = 10;int smk_access (char *subject_label,char *object_label,int request) {u32 may =MAY_NOT ; -struct smk_list_entry *sp;struct smack_rule *srp;/* @@ -139,8 +138,8 @@ int smk_access(char *subject_label, char *object_label, int request)* access (e.g. read is included in readwrite) it's * good. */ -for (sp = smack_list; sp !=NULL ; sp = sp->smk_next) { - srp = &sp->smk_rule; + +list_for_each_entry (srp, &smack_rule_list, list) {Quoted 6 lines
security/smack/smack_access.c int smk_access(char *subject_label, char *object_label, int request) · line 145
Quoted 2 lines
security/smack/smack_access.c +0
-0if (srp->smk_subject == subject_label ||strcmp (srp->smk_subject, subject_label) ==0 ) {Use of standard doubly linked list requires a lock, doesn't it? What lock protects
smack_rule_list?
Quoted 4 lines
you're right;
what's the best way, using a rcu variant for "
list_for_each,container_of...etc" ? (concurrent list insertion are already protected with a mutex, so rcu must the good idea for the read side)
You want list_for_each_entry_rcu() above. You will need list_add_rcu() when adding elements to the list.
Again, if these elements are ever removed, you will need rcu_read_lock() and rcu_read_unlock() surrounding their use. Otherwise, an element can be freed out from under a reader who is still referencing it.
Thanx, Paul
Casey Schaufler
maintainerQuoted 40 lines · Paul E. McKenney
Quoted 32 lines · etienne
Quoted 23 lines · Tetsuo Handa
Quoted 21 lines · etienne
security/smack/smack_access.c +2
-3@@ -87,7 +87,6 @@ static u32 smack_next_secid = 10;int smk_access (char *subject_label,char *object_label,int request) {u32 may =MAY_NOT ; -struct smk_list_entry *sp;struct smack_rule *srp;/* @@ -139,8 +138,8 @@ int smk_access(char *subject_label, char *object_label, int request)* access (e.g. read is included in readwrite) it's * good. */ -for (sp = smack_list; sp !=NULL ; sp = sp->smk_next) { - srp = &sp->smk_rule; + +list_for_each_entry (srp, &smack_rule_list, list) {Quoted 7 lines
security/smack/smack_access.c int smk_access(char *subject_label, char *object_label, int request) · line 145
Quoted 3 lines
security/smack/smack_access.c +0
-0if (srp->smk_subject == subject_label ||strcmp (srp->smk_subject, subject_label) ==0 ) {Use of standard doubly linked list requires a lock, doesn't it? What lock protects
smack_rule_list?Quoted 5 lines
you're right;
what's the best way, using a rcu variant for "
list_for_each,container_of...etc" ? (concurrent list insertion are already protected with a mutex, so rcu must the good idea for the read side)
Quoted 9 lines
You want
list_for_each_entry_rcu()above. You will needlist_add_rcu()when adding elements to the list.Again, if these elements are ever removed, you will need
rcu_read_lock()andrcu_read_unlock()surrounding their use. Otherwise, an element can be freed out from under a reader who is still referencing it.Thanx, Paul
You'll also need to be very careful that the locking is safe to use in the networking hooks, in particular smack_socket_sock_rcv_skb. The amount of care required to get the locking correct is a major factor in the current list implementation.
Quoted 44 lines · Casey Schaufler
Quoted 43 lines · Paul E. McKenney
Quoted 32 lines · etienne
Quoted 23 lines · Tetsuo Handa
Quoted 21 lines · etienne
security/smack/smack_access.c +2
-3@@ -87,7 +87,6 @@ static u32 smack_next_secid = 10;int smk_access (char *subject_label,char *object_label,int request) {u32 may =MAY_NOT ; -struct smk_list_entry *sp;struct smack_rule *srp;/* @@ -139,8 +138,8 @@ int smk_access(char *subject_label, char *object_label, int request)* access (e.g. read is included in readwrite) it's * good. */ -for (sp = smack_list; sp !=NULL ; sp = sp->smk_next) { - srp = &sp->smk_rule; + +list_for_each_entry (srp, &smack_rule_list, list) {Quoted 7 lines
security/smack/smack_access.c int smk_access(char *subject_label, char *object_label, int request) · line 145
Quoted 3 lines
security/smack/smack_access.c +0
-0if (srp->smk_subject == subject_label ||strcmp (srp->smk_subject, subject_label) ==0 ) {Use of standard doubly linked list requires a lock, doesn't it? What lock protects
smack_rule_list?Quoted 5 lines
you're right;
what's the best way, using a rcu variant for "
list_for_each,container_of...etc" ? (concurrent list insertion are already protected with a mutex, so rcu must the good idea for the read side)You want
list_for_each_entry_rcu()above. You will needlist_add_rcu()when adding elements to the list.
Quoted 8 lines
Quoted 3 lines
Again, if these elements are ever removed, you will need
rcu_read_lock()andrcu_read_unlock()surrounding their use. Otherwise, an element can be freed out from under a reader who is still referencing it.You'll also need to be very careful that the locking is safe to use in the networking hooks, in particular
smack_socket_sock_rcv_skb. The amount of care required to get the locking correct is a major factor in the current list implementation.
I must defer to you on this one!
Thanx, Paul