Skip to contentSkip to conversation

convert smack rule list to linux list

PATCH In review etienne 4 participants 10 messages Feb 22, 2009

Subsystems (2)
lore
Share & tools
lore

etienne

author
#0 lore raw

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
index 0b21ccd..d0b2646 100644
@@ -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
index 2e0b83e..3dc312d 100644
@@ -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

#1 lore raw
Quoted 13 lines · etienne
security/smack/smack_access.c +0 -1
index 2e0b83e..3dc312d 100644
@@ -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?

#2 lore raw

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. */
struct smack_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.

author
#4 lore raw
In reply to Tetsuo Handa
Quoted 22 lines · Tetsuo Handa
Quoted 21 lines · etienne
security/smack/smack_access.c +2 -3
index 2e0b83e..3dc312d 100644
@@ -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 -0
 		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?

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

#5 lore raw
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.

author
#6 lore raw
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

#3 lore raw
In reply to Tetsuo Handa
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. */
struct smack_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

#7 lore raw
In reply to etienne
Quoted 29 lines · etienne
Quoted 22 lines · Tetsuo Handa
Quoted 21 lines · etienne
security/smack/smack_access.c +2 -3
index 2e0b83e..3dc312d 100644
@@ -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 -0
 		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?

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

maintainer
#8 lore raw
Quoted 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
index 2e0b83e..3dc312d 100644
@@ -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 -0
 		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?

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 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

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.

#9 lore raw
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
index 2e0b83e..3dc312d 100644
@@ -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 -0
 		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?

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 need list_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() and rcu_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