Skip to contentSkip to conversation

tracepoints: prevents null probe from being added

PATCH Superseded [email protected] 3 participants 10 messages Mar 20, 2013 – Mar 21, 2013 Tracing

v1 of 3 Superseded Latest is v3 →

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 tracepoints: prevents null probe from being added

From: Sahara <[email protected]>

Somehow tracepoint_entry_add/remove_probe functions allow a null probe function. Especially on getting a null probe in remove function, it seems to be used to remove all probe functions in the entry.
But, the code is not handled as expected. Since the tracepoint_entry maintains funcs array's last func as NULL in order to mark it as the end of the array. Also NULL func is used in for-loop to check out the end of the loop. So if there's NULL func in the entry's funcs, the for-loop will be abruptly ended in the middle of operation.
Also checking out if probe is null in for-loop is not efficient.

---
 kernel/tracepoint.c |   18 ++++++++++++------
 1 files changed, 12 insertions(+), 6 deletions(-)
kernel/tracepoint.c +12 -6
index 0c05a45..30f427e 100644
@@ -112,7 +112,10 @@ tracepoint_entry_add_probe(struct tracepoint_entry *entry,
 	int nr_probes = 0;
 	struct tracepoint_func *old, *new;
 
-	WARN_ON(!probe);
+	if (unlikely(!probe)) {
+		WARN_ON(!probe);
+		return ERR_PTR(-EINVAL);
+	}
 
 	debug_print_probes(entry);
 	old = entry->funcs;
@@ -147,15 +150,19 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *entry,
 
 	old = entry->funcs;
 
+	if (unlikely(!probe)) {
+		WARN_ON(!probe);
+		return ERR_PTR(-EINVAL);
+	}
+
 	if (!old)
 		return ERR_PTR(-ENOENT);
 
 	debug_print_probes(entry);
 	/* (N -> M), (N > 1, M >= 0) probes */
 	for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
-		if (!probe ||
-		    (old[nr_probes].func == probe &&
-		     old[nr_probes].data == data))
+		if (old[nr_probes].func == probe &&
+		     old[nr_probes].data == data)
 			nr_del++;
 	}
 
@@ -173,8 +180,7 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *entry,
 		if (new == NULL)
 			return ERR_PTR(-ENOMEM);
 		for (i = 0; old[i].func; i++)
-			if (probe &&
-			    (old[i].func != probe || old[i].data != data))
+			if (old[i].func != probe || old[i].data != data)
 				new[j++] = old[i];
 		new[nr_probes - nr_del].func = NULL;
 		entry->refcount = nr_probes - nr_del;
Signature · 1 line
1.7.1
maintainer
#1 lore raw
Quoted 4 lines · On Wed, 2013-03-20 at 12:18 +0900, [email protected] wrote:

From: Sahara <[email protected]>

Somehow tracepoint_entry_add/remove_probe functions allow a null probe function.

You actually hit this in practice, or is this just something that you observe from code review?

Quoted 2 lines

Especially on getting a null probe in remove function, it seems
to be used to remove all probe functions in the entry.

Hmm, that actually sounds like a feature.

Quoted 17 lines

But, the code is not handled as expected. Since the tracepoint_entry maintains funcs array's last func as NULL in order to mark it as the end of the array. Also NULL func is used in for-loop to check out the end of the loop. So if there's NULL func in the entry's funcs, the for-loop will be abruptly ended in the middle of operation.
Also checking out if probe is null in for-loop is not efficient.

---
 kernel/tracepoint.c |   18 ++++++++++++------
 1 files changed, 12 insertions(+), 6 deletions(-)
kernel/tracepoint.c +0 -0
index 0c05a45..30f427e 100644

kernel/tracepoint.c tracepoint_entry_add_probe(struct tracepoint_entry *entry, · line 118

Quoted 8 lines
kernel/tracepoint.c +4 -1
@@ -112,7 +112,10 @@ tracepoint_entry_add_probe(struct tracepoint_entry *entry,
 	int nr_probes = 0;
 	struct tracepoint_func *old, *new;
 
-	WARN_ON(!probe);
+	if (unlikely(!probe)) {
+		WARN_ON(!probe);
+		return ERR_PTR(-EINVAL);
+	}

Um, you want:

	if (WARN_ON(!probe))
		return ERR_PTR(-EINVAL);

kernel/tracepoint.c tracepoint_entry_remove_probe(struct tracepoint_entry *entry, · line 156

Quoted 11 lines
kernel/tracepoint.c +4 -0
 	debug_print_probes(entry);
 	old = entry->funcs;
@@ -147,15 +150,19 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *entry,
 
 	old = entry->funcs;
 
+	if (unlikely(!probe)) {
+		WARN_ON(!probe);
+		return ERR_PTR(-EINVAL);
+	}

Here too if it wasn't intended to allow removal of all probes from a tracepoint.

Quoted 16 lines
kernel/tracepoint.c +3 -3
+
 	if (!old)
 		return ERR_PTR(-ENOENT);
 
 	debug_print_probes(entry);
 	/* (N -> M), (N > 1, M >= 0) probes */
 	for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
-		if (!probe ||
-		    (old[nr_probes].func == probe &&
-		     old[nr_probes].data == data))
+		if (old[nr_probes].func == probe &&
+		     old[nr_probes].data == data)
 			nr_del++;
 	}
 

kernel/tracepoint.c tracepoint_entry_remove_probe(struct tracepoint_entry *entry, · line 183

Quoted 6 lines
kernel/tracepoint.c +1 -2
@@ -173,8 +180,7 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *entry,
 		if (new == NULL)
 			return ERR_PTR(-ENOMEM);
 		for (i = 0; old[i].func; i++)
-			if (probe &&
-			    (old[i].func != probe || old[i].data != data))
+			if (old[i].func != probe || old[i].data != data)

This makes it look like the null probe was intentional.

-- Steve

Quoted 3 lines
kernel/tracepoint.c +0 -0
 				new[j++] = old[i];
 		new[nr_probes - nr_del].func = NULL;
 		entry->refcount = nr_probes - nr_del;
#2 lore raw
Quoted 6 lines · * Steven Rostedt ([email protected]) wrote:
Quoted 4 lines · On Wed, 2013-03-20 at 12:18 +0900, [email protected] wrote:

From: Sahara <[email protected]>

Somehow tracepoint_entry_add/remove_probe functions allow a null probe function.

Quoted 7 lines

You actually hit this in practice, or is this just something that you observe from code review?

Quoted 2 lines

Especially on getting a null probe in remove function, it seems
to be used to remove all probe functions in the entry.

Hmm, that actually sounds like a feature.

Yep. It's been a long time since I wrote this code, but the removal code seems to use NULL probe pointer to remove all probes for a given tracepoint.

I'd be tempted to just validate non-NULL probe within tracepoint_entry_add_probe() and let other sites as is, just in case anyone would be using this feature.

I cannot say that I have personally used this "remove all" feature much though.

Thanks,

Mathieu

Quoted 79 lines
Quoted 18 lines

But, the code is not handled as expected. Since the tracepoint_entry maintains funcs array's last func as NULL in order to mark it as the end of the array. Also NULL func is used in for-loop to check out the end of the loop. So if there's NULL func in the entry's funcs, the for-loop will be abruptly ended in the middle of operation.
Also checking out if probe is null in for-loop is not efficient.

---
 kernel/tracepoint.c |   18 ++++++++++++------
 1 files changed, 12 insertions(+), 6 deletions(-)
kernel/tracepoint.c +0 -0
index 0c05a45..30f427e 100644

kernel/tracepoint.c tracepoint_entry_add_probe(struct tracepoint_entry *entry, · line 118

Quoted 8 lines
kernel/tracepoint.c +4 -1
@@ -112,7 +112,10 @@ tracepoint_entry_add_probe(struct tracepoint_entry *entry,
 	int nr_probes = 0;
 	struct tracepoint_func *old, *new;
 
-	WARN_ON(!probe);
+	if (unlikely(!probe)) {
+		WARN_ON(!probe);
+		return ERR_PTR(-EINVAL);
+	}

Um, you want:

	if (WARN_ON(!probe))
		return ERR_PTR(-EINVAL);

kernel/tracepoint.c tracepoint_entry_remove_probe(struct tracepoint_entry *entry, · line 156

Quoted 11 lines
kernel/tracepoint.c +4 -0
 	debug_print_probes(entry);
 	old = entry->funcs;
@@ -147,15 +150,19 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *entry,
 
 	old = entry->funcs;
 
+	if (unlikely(!probe)) {
+		WARN_ON(!probe);
+		return ERR_PTR(-EINVAL);
+	}

Here too if it wasn't intended to allow removal of all probes from a tracepoint.

Quoted 16 lines
kernel/tracepoint.c +3 -3
+
 	if (!old)
 		return ERR_PTR(-ENOENT);
 
 	debug_print_probes(entry);
 	/* (N -> M), (N > 1, M >= 0) probes */
 	for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
-		if (!probe ||
-		    (old[nr_probes].func == probe &&
-		     old[nr_probes].data == data))
+		if (old[nr_probes].func == probe &&
+		     old[nr_probes].data == data)
 			nr_del++;
 	}
 

kernel/tracepoint.c tracepoint_entry_remove_probe(struct tracepoint_entry *entry, · line 183

Quoted 6 lines
kernel/tracepoint.c +1 -2
@@ -173,8 +180,7 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *entry,
 		if (new == NULL)
 			return ERR_PTR(-ENOMEM);
 		for (i = 0; old[i].func; i++)
-			if (probe &&
-			    (old[i].func != probe || old[i].data != data))
+			if (old[i].func != probe || old[i].data != data)

This makes it look like the null probe was intentional.

-- Steve

Quoted 3 lines
kernel/tracepoint.c +0 -0
 				new[j++] = old[i];
 		new[nr_probes - nr_del].func = NULL;
 		entry->refcount = nr_probes - nr_del;
Signature · 3 lines
Mathieu Desnoyers
EfficiOS Inc.
http://www.efficios.com
maintainer
#3 lore raw
Quoted 19 lines · Mathieu Desnoyers
Quoted 6 lines · * Steven Rostedt ([email protected]) wrote:
Quoted 4 lines · On Wed, 2013-03-20 at 12:18 +0900, [email protected] wrote:

From: Sahara <[email protected]>

Somehow tracepoint_entry_add/remove_probe functions allow a null probe function.

Quoted 7 lines

You actually hit this in practice, or is this just something that you observe from code review?

Quoted 2 lines

Especially on getting a null probe in remove function, it seems
to be used to remove all probe functions in the entry.

Hmm, that actually sounds like a feature.

Yep. It's been a long time since I wrote this code, but the removal code seems to use NULL probe pointer to remove all probes for a given tracepoint.

Quoted 7 lines

I'd be tempted to just validate non-NULL probe within tracepoint_entry_add_probe() and let other sites as is, just in case anyone would be using this feature.

I cannot say that I have personally used this "remove all" feature much though.

I agree. I don't see anything wrong in leaving the null probe feature in the removal code. But updating the add code looks like a proper change.

-- Steve

#4 lore raw
Quoted 24 lines · Steven Rostedt
Quoted 23 lines · Mathieu Desnoyers
Quoted 6 lines · * Steven Rostedt ([email protected]) wrote:
Quoted 4 lines · On Wed, 2013-03-20 at 12:18 +0900, [email protected] wrote:

From: Sahara <[email protected]>

Somehow tracepoint_entry_add/remove_probe functions allow a null probe function.

Quoted 7 lines

You actually hit this in practice, or is this just something that you observe from code review?

Quoted 2 lines

Especially on getting a null probe in remove function, it seems
to be used to remove all probe functions in the entry.

Hmm, that actually sounds like a feature.

Yep. It's been a long time since I wrote this code, but the removal code seems to use NULL probe pointer to remove all probes for a given tracepoint.

I'd be tempted to just validate non-NULL probe within tracepoint_entry_add_probe() and let other sites as is, just in case anyone would be using this feature.

Quoted 10 lines
Quoted 3 lines

I cannot say that I have personally used this "remove all" feature much though.

I agree. I don't see anything wrong in leaving the null probe feature in the removal code. But updating the add code looks like a proper change.

-- Steve

Hello Steve & Mathieu,
If we want to leave the null probe feature enabled, I think it would be better modifying the code like the following for code efficiency.

@@ -112,7 +112,8 @@ tracepoint_entry_add_probe(struct tracepoint_entry *entry,

        int nr_probes = 0;
        struct tracepoint_func *old, *new;

- WARN_ON(!probe);
+ if (WARN_ON(!probe))
+ return ERR_PTR(-EINVAL);

        debug_print_probes(entry);
        old = entry->funcs;

@@ -152,14 +153,15 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *ent

        debug_print_probes(entry);
        /* (N -> M), (N > 1, M >= 0) probes */

- for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
- if (!probe ||
- (old[nr_probes].func == probe &&
- old[nr_probes].data == data))
- nr_del++;
+ if (probe) {
+ for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
+ if (old[nr_probes].func == probe &&
+ old[nr_probes].data == data)
+ nr_del++;
+ }

        }

- if (nr_probes - nr_del == 0) {

+       if (!probe || nr_probes - nr_del == 0) {
                /* N -> 0, (N > 1) */
                entry->funcs = NULL;
                entry->refcount = 0;

Because we know handing over the null probe to tracepoint_entry_add_probe is not possible,
we don't have to check if the probe is null or not within for loop. If the probe is null, it's just enough to add !probe in 'if(nr_probes-nr_del==0)'. And, with additional if-clause wrapping for-loop, falling through for-loop can be prevented when probe is null.

@@ -173,8 +172,7 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *entry

                if (new == NULL)
                        return ERR_PTR(-ENOMEM);
                for (i = 0; old[i].func; i++)
-                       if (probe &&
-                           (old[i].func != probe || old[i].data != data))
+                       if (old[i].func != probe || old[i].data != data)
                                new[j++] = old[i];
                new[nr_probes - nr_del].func = NULL;
                entry->refcount = nr_probes - nr_del;

We don't have to check the probe here too. We know probe is always true here. Thanks.

-- Kpark

#5 lore raw
Quoted 73 lines · Keun-O Park
Quoted 24 lines · Steven Rostedt
Quoted 23 lines · Mathieu Desnoyers
Quoted 6 lines · * Steven Rostedt ([email protected]) wrote:
Quoted 4 lines · On Wed, 2013-03-20 at 12:18 +0900, [email protected] wrote:

From: Sahara <[email protected]>

Somehow tracepoint_entry_add/remove_probe functions allow a null probe function.

Quoted 7 lines

You actually hit this in practice, or is this just something that you observe from code review?

Quoted 2 lines

Especially on getting a null probe in remove function, it seems
to be used to remove all probe functions in the entry.

Hmm, that actually sounds like a feature.

Yep. It's been a long time since I wrote this code, but the removal code seems to use NULL probe pointer to remove all probes for a given tracepoint.

I'd be tempted to just validate non-NULL probe within tracepoint_entry_add_probe() and let other sites as is, just in case anyone would be using this feature.

Quoted 10 lines
Quoted 3 lines

I cannot say that I have personally used this "remove all" feature much though.

I agree. I don't see anything wrong in leaving the null probe feature in the removal code. But updating the add code looks like a proper change.

-- Steve

Hello Steve & Mathieu,
If we want to leave the null probe feature enabled, I think it would be better modifying the code like the following for code efficiency.

kernel/tracepoint.c +9 -7
@@ -112,7 +112,8 @@ tracepoint_entry_add_probe(struct tracepoint_entry *entry,
        int nr_probes = 0;
        struct tracepoint_func *old, *new;
 
-       WARN_ON(!probe);
+       if (WARN_ON(!probe))
+               return ERR_PTR(-EINVAL);
 
        debug_print_probes(entry);
        old = entry->funcs;
@@ -152,14 +153,15 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *ent
 
        debug_print_probes(entry);
        /* (N -> M), (N > 1, M >= 0) probes */
-       for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
-               if (!probe ||
-                   (old[nr_probes].func == probe &&
-                    old[nr_probes].data == data))
-                       nr_del++;
+       if (probe) {
+               for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
+                       if (old[nr_probes].func == probe &&
+                            old[nr_probes].data == data)
+                               nr_del++;
+               }
        }
 
-       if (nr_probes - nr_del == 0) {
+       if (!probe || nr_probes - nr_del == 0) {
                /* N -> 0, (N > 1) */
                entry->funcs = NULL;
                entry->refcount = 0;
Quoted 3 lines

Because we know handing over the null probe to tracepoint_entry_add_probe is not possible,
we don't have to check if the probe is null or not within for loop. If

Hmm. I described this wrong. :-(
For code efficiency, I replaced 'checking null probe in every iteration within for-loop' with 'checking once outside the loop'.

Quoted 20 lines

the probe is null, it's just enough to add !probe in 'if(nr_probes-nr_del==0)'. And, with additional if-clause wrapping for-loop, falling through for-loop can be prevented when probe is null.

kernel/tracepoint.c +1 -2
@@ -173,8 +172,7 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *entry
                if (new == NULL)
                        return ERR_PTR(-ENOMEM);
                for (i = 0; old[i].func; i++)
-                       if (probe &&
-                           (old[i].func != probe || old[i].data != data))
+                       if (old[i].func != probe || old[i].data != data)
                                new[j++] = old[i];
                new[nr_probes - nr_del].func = NULL;
                entry->refcount = nr_probes - nr_del;

We don't have to check the probe here too. We know probe is always true here. Thanks.

-- Kpark

#6 lore raw
In reply to Keun-O Park
Quoted 59 lines · * Keun-O Park ([email protected]) wrote:
Quoted 24 lines · Steven Rostedt
Quoted 23 lines · Mathieu Desnoyers
Quoted 6 lines · * Steven Rostedt ([email protected]) wrote:
Quoted 4 lines · On Wed, 2013-03-20 at 12:18 +0900, [email protected] wrote:

From: Sahara <[email protected]>

Somehow tracepoint_entry_add/remove_probe functions allow a null probe function.

Quoted 7 lines

You actually hit this in practice, or is this just something that you observe from code review?

Quoted 2 lines

Especially on getting a null probe in remove function, it seems
to be used to remove all probe functions in the entry.

Hmm, that actually sounds like a feature.

Yep. It's been a long time since I wrote this code, but the removal code seems to use NULL probe pointer to remove all probes for a given tracepoint.

I'd be tempted to just validate non-NULL probe within tracepoint_entry_add_probe() and let other sites as is, just in case anyone would be using this feature.

Quoted 10 lines
Quoted 3 lines

I cannot say that I have personally used this "remove all" feature much though.

I agree. I don't see anything wrong in leaving the null probe feature in the removal code. But updating the add code looks like a proper change.

-- Steve

Hello Steve & Mathieu,
If we want to leave the null probe feature enabled, I think it would be better modifying the code like the following for code efficiency.

kernel/tracepoint.c +2 -6
@@ -112,7 +112,8 @@ tracepoint_entry_add_probe(struct tracepoint_entry *entry,
        int nr_probes = 0;
        struct tracepoint_func *old, *new;
 
-       WARN_ON(!probe);
+       if (WARN_ON(!probe))
+               return ERR_PTR(-EINVAL);
 
        debug_print_probes(entry);
        old = entry->funcs;
@@ -152,14 +153,15 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *ent
 
        debug_print_probes(entry);
        /* (N -> M), (N > 1, M >= 0) probes */
-       for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
-               if (!probe ||
-                   (old[nr_probes].func == probe &&
-                    old[nr_probes].data == data))
-                       nr_del++;

kernel/tracepoint.c tracepoint_entry_remove_probe(struct tracepoint_entry *ent · line 164

Quoted 10 lines
kernel/tracepoint.c +7 -1
+       if (probe) {
+               for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
+                       if (old[nr_probes].func == probe &&
+                            old[nr_probes].data == data)
+                               nr_del++;
+               }
        }
 
-       if (nr_probes - nr_del == 0) {
+       if (!probe || nr_probes - nr_del == 0) {

We might want to do:

if (probe) {
...
} else {
nr_del = nr_probes;
}

if (nr_probes - nr_del == 0) {
...
}

rather than:

if (probe) {
...
}

if (!probe || nr_probes - nr_del == 0) {
...
}

Using nr_del makes the code easier to follow IMHO.

Thanks,

Mathieu

Quoted 27 lines
(quoted diff) +0 -0
                /* N -> 0, (N > 1) */
                entry->funcs = NULL;
                entry->refcount = 0;

Because we know handing over the null probe to tracepoint_entry_add_probe is not possible,
we don't have to check if the probe is null or not within for loop. If the probe is null, it's just enough to add !probe in 'if(nr_probes-nr_del==0)'. And, with additional if-clause wrapping for-loop, falling through for-loop can be prevented when probe is null.

kernel/tracepoint.c +1 -2
@@ -173,8 +172,7 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *entry
                if (new == NULL)
                        return ERR_PTR(-ENOMEM);
                for (i = 0; old[i].func; i++)
-                       if (probe &&
-                           (old[i].func != probe || old[i].data != data))
+                       if (old[i].func != probe || old[i].data != data)
                                new[j++] = old[i];
                new[nr_probes - nr_del].func = NULL;
                entry->refcount = nr_probes - nr_del;

We don't have to check the probe here too. We know probe is always true here. Thanks.

-- Kpark

Signature · 3 lines
Mathieu Desnoyers
EfficiOS Inc.
http://www.efficios.com
#7 lore raw
Quoted 79 lines · Mathieu Desnoyers
Quoted 59 lines · * Keun-O Park ([email protected]) wrote:
Quoted 24 lines · Steven Rostedt
Quoted 23 lines · Mathieu Desnoyers
Quoted 6 lines · * Steven Rostedt ([email protected]) wrote:
Quoted 4 lines · On Wed, 2013-03-20 at 12:18 +0900, [email protected] wrote:

From: Sahara <[email protected]>

Somehow tracepoint_entry_add/remove_probe functions allow a null probe function.

Quoted 7 lines

You actually hit this in practice, or is this just something that you observe from code review?

Quoted 2 lines

Especially on getting a null probe in remove function, it seems
to be used to remove all probe functions in the entry.

Hmm, that actually sounds like a feature.

Yep. It's been a long time since I wrote this code, but the removal code seems to use NULL probe pointer to remove all probes for a given tracepoint.

I'd be tempted to just validate non-NULL probe within tracepoint_entry_add_probe() and let other sites as is, just in case anyone would be using this feature.

Quoted 10 lines
Quoted 3 lines

I cannot say that I have personally used this "remove all" feature much though.

I agree. I don't see anything wrong in leaving the null probe feature in the removal code. But updating the add code looks like a proper change.

-- Steve

Hello Steve & Mathieu,
If we want to leave the null probe feature enabled, I think it would be better modifying the code like the following for code efficiency.

kernel/tracepoint.c +2 -6
@@ -112,7 +112,8 @@ tracepoint_entry_add_probe(struct tracepoint_entry *entry,
        int nr_probes = 0;
        struct tracepoint_func *old, *new;
 
-       WARN_ON(!probe);
+       if (WARN_ON(!probe))
+               return ERR_PTR(-EINVAL);
 
        debug_print_probes(entry);
        old = entry->funcs;
@@ -152,14 +153,15 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *ent
 
        debug_print_probes(entry);
        /* (N -> M), (N > 1, M >= 0) probes */
-       for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
-               if (!probe ||
-                   (old[nr_probes].func == probe &&
-                    old[nr_probes].data == data))
-                       nr_del++;

kernel/tracepoint.c tracepoint_entry_remove_probe(struct tracepoint_entry *ent · line 164

Quoted 10 lines
kernel/tracepoint.c +7 -1
+       if (probe) {
+               for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
+                       if (old[nr_probes].func == probe &&
+                            old[nr_probes].data == data)
+                               nr_del++;
+               }
        }
 
-       if (nr_probes - nr_del == 0) {
+       if (!probe || nr_probes - nr_del == 0) {

We might want to do:

if (probe) {
...
} else {
nr_del = nr_probes;
}

Quoted 3 lines
if (nr_probes - nr_del == 0) {
   ...
}

This code has a problem.
nr_probes is initialized as zero. And, in order to get correct count of probes, we need to go through the for-loop even though probe is null.
So with above code, nr_del will be zero. Anyhow, the code will fall through if-clause(nr_probes-nr_del==0).
It looks odd to me.

-- Kpark

Quoted 17 lines

rather than:

if (probe) {
...
}

if (!probe || nr_probes - nr_del == 0) {
   ...
}

Using nr_del makes the code easier to follow IMHO.

Thanks,

Mathieu

#8 lore raw
Quoted 81 lines · * Keun-O Park ([email protected]) wrote:
Quoted 79 lines · Mathieu Desnoyers
Quoted 59 lines · * Keun-O Park ([email protected]) wrote:
Quoted 24 lines · Steven Rostedt
Quoted 23 lines · Mathieu Desnoyers
Quoted 6 lines · * Steven Rostedt ([email protected]) wrote:
Quoted 4 lines · On Wed, 2013-03-20 at 12:18 +0900, [email protected] wrote:

From: Sahara <[email protected]>

Somehow tracepoint_entry_add/remove_probe functions allow a null probe function.

Quoted 7 lines

You actually hit this in practice, or is this just something that you observe from code review?

Quoted 2 lines

Especially on getting a null probe in remove function, it seems
to be used to remove all probe functions in the entry.

Hmm, that actually sounds like a feature.

Yep. It's been a long time since I wrote this code, but the removal code seems to use NULL probe pointer to remove all probes for a given tracepoint.

I'd be tempted to just validate non-NULL probe within tracepoint_entry_add_probe() and let other sites as is, just in case anyone would be using this feature.

Quoted 10 lines
Quoted 3 lines

I cannot say that I have personally used this "remove all" feature much though.

I agree. I don't see anything wrong in leaving the null probe feature in the removal code. But updating the add code looks like a proper change.

-- Steve

Hello Steve & Mathieu,
If we want to leave the null probe feature enabled, I think it would be better modifying the code like the following for code efficiency.

(quoted diff) +2 -6
@@ -112,7 +112,8 @@ tracepoint_entry_add_probe(struct tracepoint_entry *entry,
        int nr_probes = 0;
        struct tracepoint_func *old, *new;
 
-       WARN_ON(!probe);
+       if (WARN_ON(!probe))
+               return ERR_PTR(-EINVAL);
 
        debug_print_probes(entry);
        old = entry->funcs;
@@ -152,14 +153,15 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *ent
 
        debug_print_probes(entry);
        /* (N -> M), (N > 1, M >= 0) probes */
-       for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
-               if (!probe ||
-                   (old[nr_probes].func == probe &&
-                    old[nr_probes].data == data))
-                       nr_del++;

Review tracepoint_entry_remove_probe(struct tracepoint_entry *ent · line 164

Quoted 10 lines
(quoted diff) +7 -1
+       if (probe) {
+               for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
+                       if (old[nr_probes].func == probe &&
+                            old[nr_probes].data == data)
+                               nr_del++;
+               }
        }
 
-       if (nr_probes - nr_del == 0) {
+       if (!probe || nr_probes - nr_del == 0) {

We might want to do:

if (probe) {
...
} else {
nr_del = nr_probes;
}

Quoted 6 lines
Quoted 3 lines
if (nr_probes - nr_del == 0) {
   ...
}

This code has a problem.
nr_probes is initialized as zero.

yes,

Quoted 5 lines

And, in order to get correct count of probes,
we need to go through the for-loop even though probe is null. So with above code, nr_del will be zero. Anyhow, the code will fall through if-clause(nr_probes-nr_del==0).
It looks odd to me.

Ah, I see what you mean: the nr_del = nr_probes assignment is useless, because both nr_probes and nr_del are equal to 0. So we could go for:

        if (probe) {
                for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
                        if (old[nr_probes].func == probe &&
                             old[nr_probes].data == data)
                                nr_del++;
                }
        }

        if (nr_probes - nr_del == 0) {
                ...
        } else {
                ...
        }

Does it look better ?

Thanks,

Mathieu

Quoted 20 lines

-- Kpark

Quoted 17 lines

rather than:

if (probe) {
...
}

if (!probe || nr_probes - nr_del == 0) {
   ...
}

Using nr_del makes the code easier to follow IMHO.

Thanks,

Mathieu

Signature · 3 lines
Mathieu Desnoyers
EfficiOS Inc.
http://www.efficios.com
#9 lore raw
Quoted 114 lines · Mathieu Desnoyers
Quoted 81 lines · * Keun-O Park ([email protected]) wrote:
Quoted 79 lines · Mathieu Desnoyers
Quoted 59 lines · * Keun-O Park ([email protected]) wrote:
Quoted 24 lines · Steven Rostedt
Quoted 23 lines · Mathieu Desnoyers
Quoted 6 lines · * Steven Rostedt ([email protected]) wrote:
Quoted 4 lines · On Wed, 2013-03-20 at 12:18 +0900, [email protected] wrote:

From: Sahara <[email protected]>

Somehow tracepoint_entry_add/remove_probe functions allow a null probe function.

Quoted 7 lines

You actually hit this in practice, or is this just something that you observe from code review?

Quoted 2 lines

Especially on getting a null probe in remove function, it seems
to be used to remove all probe functions in the entry.

Hmm, that actually sounds like a feature.

Yep. It's been a long time since I wrote this code, but the removal code seems to use NULL probe pointer to remove all probes for a given tracepoint.

I'd be tempted to just validate non-NULL probe within tracepoint_entry_add_probe() and let other sites as is, just in case anyone would be using this feature.

Quoted 10 lines
Quoted 3 lines

I cannot say that I have personally used this "remove all" feature much though.

I agree. I don't see anything wrong in leaving the null probe feature in the removal code. But updating the add code looks like a proper change.

-- Steve

Hello Steve & Mathieu,
If we want to leave the null probe feature enabled, I think it would be better modifying the code like the following for code efficiency.

(quoted diff) +2 -6
@@ -112,7 +112,8 @@ tracepoint_entry_add_probe(struct tracepoint_entry *entry,
        int nr_probes = 0;
        struct tracepoint_func *old, *new;
 
-       WARN_ON(!probe);
+       if (WARN_ON(!probe))
+               return ERR_PTR(-EINVAL);
 
        debug_print_probes(entry);
        old = entry->funcs;
@@ -152,14 +153,15 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *ent
 
        debug_print_probes(entry);
        /* (N -> M), (N > 1, M >= 0) probes */
-       for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
-               if (!probe ||
-                   (old[nr_probes].func == probe &&
-                    old[nr_probes].data == data))
-                       nr_del++;

Review tracepoint_entry_remove_probe(struct tracepoint_entry *ent · line 164

Quoted 10 lines
(quoted diff) +7 -1
+       if (probe) {
+               for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
+                       if (old[nr_probes].func == probe &&
+                            old[nr_probes].data == data)
+                               nr_del++;
+               }
        }
 
-       if (nr_probes - nr_del == 0) {
+       if (!probe || nr_probes - nr_del == 0) {

We might want to do:

if (probe) {
...
} else {
nr_del = nr_probes;
}

Quoted 6 lines
Quoted 3 lines
if (nr_probes - nr_del == 0) {
   ...
}

This code has a problem.
nr_probes is initialized as zero.

yes,

Quoted 5 lines

And, in order to get correct count of probes,
we need to go through the for-loop even though probe is null. So with above code, nr_del will be zero. Anyhow, the code will fall through if-clause(nr_probes-nr_del==0).
It looks odd to me.

Ah, I see what you mean: the nr_del = nr_probes assignment is useless, because both nr_probes and nr_del are equal to 0. So we could go for:

        if (probe) {
                for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
                        if (old[nr_probes].func == probe &&
                             old[nr_probes].data == data)
                                nr_del++;
                }
        }

        if (nr_probes - nr_del == 0) {
                ...
        } else {
                ...
        }
Quoted 5 lines

Does it look better ?

Thanks,

Mathieu

Yes, it does, only if you don't think this code is hard to follow. ;-) Thanks.

-- Kpark