Page MenuHomeFreeBSD
Differential D9205

Change ownership of rundeck/server/lib et al.
ClosedPublic
Actions

Authored by ler on Jan 17 2017, 12:50 AM.
Tags
None
Referenced Files
Unknown Object (File)
Sun, Mar 9, 11:35 AM
Unknown Object (File)
Tue, Mar 4, 12:27 PM
Unknown Object (File)
Tue, Mar 4, 11:43 AM
Unknown Object (File)
Feb 17 2025, 2:35 AM
Unknown Object (File)
Feb 17 2025, 2:29 AM
Unknown Object (File)
Jan 27 2025, 1:01 AM
Unknown Object (File)
Jan 22 2025, 6:45 PM
Unknown Object (File)
Jan 22 2025, 3:48 PM
View All Files
Subscribers
mat

Details

Reviewers
adamw
rene
Commits
rP431715: Change ownership of rundeck/server/lib et al.
Summary

Change ownership of rundeck/server/lib et al.
Address poudriere issues
bump PORTREVISION

PR: 202732
Submitted by: Mark C Ballew (ballew sublinear net)
Approved by: (adamw|rene) (mentor)
MFH: 2017Q1 (blanket)

Test Plan

poudriere (ok)
http://home.lerctr.org:8888/data/live-ler-checkout/2017-01-16_18h42m54s/logs/rundeck-2.3.2_1.log

portlint (ok)
borg.lerctr.org ~/FreeBSD/ports/sysutils/rundeck $ portlint -C
WARN: Makefile: possible use of absolute pathname "/var/log/rundeck.log".
0 fatal errors and 1 warning found.
borg.lerctr.org ~/FreeBSD/ports/sysutils/rundeck $

Diff Detail

Repository
rP FreeBSD ports repository
Lint
No Lint Coverage
Unit
No Test Coverage
Build Status
Buildable 6812
Build 7018: arc lint + arc unit

Event Timeline

ler updated this revision to Diff 24091.Jan 17 2017, 12:50 AM
ler retitled this revision from to Change ownership of rundeck/server/lib et al..
ler updated this object.
ler edited the test plan for this revision. (Show Details)
ler added reviewers: adamw, rene.
Herald added a subscriber: mat. · View Herald TranscriptJan 17 2017, 12:50 AM
adamw edited edge metadata.Jan 17 2017, 12:51 AM

You should follow portlint's advice.

ler updated this object.Jan 17 2017, 12:52 AM
ler edited edge metadata.
adamw added inline comments.Jan 17 2017, 12:52 AM
sysutils/rundeck/pkg-plist
3

@dir goes at the end of the plist.

adamw added inline comments.Jan 17 2017, 12:54 AM
sysutils/rundeck/Makefile
42

${MKDIR} commands should be muted.

43

Now that you have @dir in the plist, you don't need to create this file.

sysutils/rundeck/pkg-plist
4

You have @dir. You don't need to trick the system with a .keep file.

ler updated this revision to Diff 24092.Jan 17 2017, 12:55 AM

Address portlint DATADIR

ler updated this revision to Diff 24093.Jan 17 2017, 12:56 AM

Uh, use the right diff.

ler edited the test plan for this revision. (Show Details)Jan 17 2017, 12:57 AM
ler updated this revision to Diff 24094.Jan 17 2017, 12:58 AM

update plist per Adam

ler updated this revision to Diff 24095.Jan 17 2017, 1:05 AM

Address Adam's comment re: .keep

ler marked 4 inline comments as done.Jan 17 2017, 1:06 AM
adamw accepted this revision.Jan 17 2017, 1:13 AM
adamw edited edge metadata.
adamw added inline comments.
sysutils/rundeck/pkg-plist
4

These @dir entries should be in reverse-alphabetical order. Just switch them before committing.

This revision is now accepted and ready to land.Jan 17 2017, 1:13 AM
Closed by commit rP431715: Change ownership of rundeck/server/lib et al. (authored by ler). · Explain WhyJan 17 2017, 1:22 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 24092

View Options

MOVED

Show First 20 Lines • Show All 1,240 Lines • ▼ Show 20 Linesthread_single(struct proc *p, int mode)
/* /*
* Is someone already single threading? * Is someone already single threading?
* Or may be singlethreading is not needed at all. * Or may be singlethreading is not needed at all.
*/ */
if (mode == SINGLE_ALLPROC) { if (mode == SINGLE_ALLPROC) {
while ((p->p_flag & P_STOPPED_SINGLE) != 0) { while ((p->p_flag & P_STOPPED_SINGLE) != 0) {
if ((p->p_flag2 & P2_WEXIT) != 0) if ((p->p_flag2 & P2_WEXIT) != 0)
return (1); return (1);
msleep(&p->p_flag, &p->p_mtx, PCATCH, "thrsgl", 0); msleep(&p->p_flag, &p->p_mtx, PCATCH, "thrsgl", 0);
markjUnsubmitted
Not Done
Inline Actions

So, the problem is that reap_kill_proc_locked() can block here while single-threading the debuggee? Then, shouldn't the checks come before this loop? Otherwise I do not quite understand the problem.

markj: So, the problem is that reap_kill_proc_locked() can block here while single-threading the…
kibAuthorUnsubmitted
Done
Inline Actions

This check must be atomic WRT setting the P_TOTAL_STOP flag. If done before the loop, which checks for other single-threading reasons, it would allow the race.

After the loop, we know that no other single-threading request can be active (it is blocked waiting for the process lock).

Then, the patch checks for P_TRACED so that debugger attempt to suspend all process threads (which is very similar but not covered by thread_single(), see sig_suspend_threads()) does not mess with our single-threading. This confusion, when two different suspensions (sig_suspend_threads() vs. P_TOTAL_STOP) act simultaneously, is the root cause of the reported hang.

kib: This check must be atomic WRT setting the P_TOTAL_STOP flag. If done before the loop, which…
markjUnsubmitted
Not Done
Inline Actions

I'm sorry, I just realized that my test isn't quite right, and looking again, I still don't understand the patch.

reap_kill_proc_locked() only calls thread_single() if P_STOPPED is not set in the target proc. So in particular, P_STOPPED_SINGLE is not set, so thread_single() will not drop the proc lock in the loop. I don't see how it can fix the problem reported by mjg.

markj: I'm sorry, I just realized that my test isn't quite right, and looking again, I still don't…
kibAuthorUnsubmitted
Done
Inline Actions

Why it is important is P_STOPPED_SINGLE set or not?

Let me formulate the goal of the patch differently: do not allow 'global' singlethreading (AKA singlethreading outside the process context) if the process is being debugged or stopped. The attributes of process being a debuggee is either P_TRACED or P_STOPPED_SIG flag.

kib: Why it is important is P_STOPPED_SINGLE set or not? Let me formulate the goal of the patch…
kibAuthorUnsubmitted
Done
Inline Actions

Might be, I understand your question. Mjg' issue is not a hang in the 'thrsgl' state. It is very different thing, which I called single-threading confusion between sig_suspend_threads() and P_TOTAL_STOP. Both requests utilize the same threads' state and same reporting (thread_suspend_one()), so if both come simultaneously, we might get some threads suspended due to ptracestop(), and other suspended due to single-threading. So my decision is to prevent P_STOP_ALL when the process is debugged.

Note that this is impossible to get into this state while single threading request comes from the process context.

kib: Might be, I understand your question. Mjg' issue is not a hang in the 'thrsgl' state. It is…
markjUnsubmitted
Not Done
Inline Actions

Thank you, I understand the bug better now and fixed my test case correspondingly.

markj: Thank you, I understand the bug better now and fixed my test case correspondingly.
} }
if ((p->p_flag & (P_STOPPED_SIG | P_TRACED)) != 0 ||
(p->p_flag2 & P2_WEXIT) != 0)
return (1);
} else if ((p->p_flag & P_HADTHREADS) == 0) } else if ((p->p_flag & P_HADTHREADS) == 0)
return (0); return (0);
if (p->p_singlethread != NULL && p->p_singlethread != td) if (p->p_singlethread != NULL && p->p_singlethread != td)
return (1); return (1);
if (mode == SINGLE_EXIT) { if (mode == SINGLE_EXIT) {
p->p_flag |= P_SINGLE_EXIT; p->p_flag |= P_SINGLE_EXIT;
p->p_flag &= ~P_SINGLE_BOUNDARY; p->p_flag &= ~P_SINGLE_BOUNDARY;
▲ Show 20 Lines • Show All 559 Lines • Show Last 20 Lines
View Options

astro/Makefile

Show First 20 Lines • Show All 1,240 Lines • ▼ Show 20 Linesthread_single(struct proc *p, int mode)
/* /*
* Is someone already single threading? * Is someone already single threading?
* Or may be singlethreading is not needed at all. * Or may be singlethreading is not needed at all.
*/ */
if (mode == SINGLE_ALLPROC) { if (mode == SINGLE_ALLPROC) {
while ((p->p_flag & P_STOPPED_SINGLE) != 0) { while ((p->p_flag & P_STOPPED_SINGLE) != 0) {
if ((p->p_flag2 & P2_WEXIT) != 0) if ((p->p_flag2 & P2_WEXIT) != 0)
return (1); return (1);
msleep(&p->p_flag, &p->p_mtx, PCATCH, "thrsgl", 0); msleep(&p->p_flag, &p->p_mtx, PCATCH, "thrsgl", 0);
markjUnsubmitted
Not Done
Inline Actions

So, the problem is that reap_kill_proc_locked() can block here while single-threading the debuggee? Then, shouldn't the checks come before this loop? Otherwise I do not quite understand the problem.

markj: So, the problem is that reap_kill_proc_locked() can block here while single-threading the…
kibAuthorUnsubmitted
Done
Inline Actions

This check must be atomic WRT setting the P_TOTAL_STOP flag. If done before the loop, which checks for other single-threading reasons, it would allow the race.

After the loop, we know that no other single-threading request can be active (it is blocked waiting for the process lock).

Then, the patch checks for P_TRACED so that debugger attempt to suspend all process threads (which is very similar but not covered by thread_single(), see sig_suspend_threads()) does not mess with our single-threading. This confusion, when two different suspensions (sig_suspend_threads() vs. P_TOTAL_STOP) act simultaneously, is the root cause of the reported hang.

kib: This check must be atomic WRT setting the P_TOTAL_STOP flag. If done before the loop, which…
markjUnsubmitted
Not Done
Inline Actions

I'm sorry, I just realized that my test isn't quite right, and looking again, I still don't understand the patch.

reap_kill_proc_locked() only calls thread_single() if P_STOPPED is not set in the target proc. So in particular, P_STOPPED_SINGLE is not set, so thread_single() will not drop the proc lock in the loop. I don't see how it can fix the problem reported by mjg.

markj: I'm sorry, I just realized that my test isn't quite right, and looking again, I still don't…
kibAuthorUnsubmitted
Done
Inline Actions

Why it is important is P_STOPPED_SINGLE set or not?

Let me formulate the goal of the patch differently: do not allow 'global' singlethreading (AKA singlethreading outside the process context) if the process is being debugged or stopped. The attributes of process being a debuggee is either P_TRACED or P_STOPPED_SIG flag.

kib: Why it is important is P_STOPPED_SINGLE set or not? Let me formulate the goal of the patch…
kibAuthorUnsubmitted
Done
Inline Actions

Might be, I understand your question. Mjg' issue is not a hang in the 'thrsgl' state. It is very different thing, which I called single-threading confusion between sig_suspend_threads() and P_TOTAL_STOP. Both requests utilize the same threads' state and same reporting (thread_suspend_one()), so if both come simultaneously, we might get some threads suspended due to ptracestop(), and other suspended due to single-threading. So my decision is to prevent P_STOP_ALL when the process is debugged.

Note that this is impossible to get into this state while single threading request comes from the process context.

kib: Might be, I understand your question. Mjg' issue is not a hang in the 'thrsgl' state. It is…
markjUnsubmitted
Not Done
Inline Actions

Thank you, I understand the bug better now and fixed my test case correspondingly.

markj: Thank you, I understand the bug better now and fixed my test case correspondingly.
} }
if ((p->p_flag & (P_STOPPED_SIG | P_TRACED)) != 0 ||
(p->p_flag2 & P2_WEXIT) != 0)
return (1);
} else if ((p->p_flag & P_HADTHREADS) == 0) } else if ((p->p_flag & P_HADTHREADS) == 0)
return (0); return (0);
if (p->p_singlethread != NULL && p->p_singlethread != td) if (p->p_singlethread != NULL && p->p_singlethread != td)
return (1); return (1);
if (mode == SINGLE_EXIT) { if (mode == SINGLE_EXIT) {
p->p_flag |= P_SINGLE_EXIT; p->p_flag |= P_SINGLE_EXIT;
p->p_flag &= ~P_SINGLE_BOUNDARY; p->p_flag &= ~P_SINGLE_BOUNDARY;
▲ Show 20 Lines • Show All 559 Lines • Show Last 20 Lines
View Options

astro/boinc-setiathome-v7/

Show First 20 Lines • Show All 1,240 Lines • ▼ Show 20 Linesthread_single(struct proc *p, int mode)
/* /*
* Is someone already single threading? * Is someone already single threading?
* Or may be singlethreading is not needed at all. * Or may be singlethreading is not needed at all.
*/ */
if (mode == SINGLE_ALLPROC) { if (mode == SINGLE_ALLPROC) {
while ((p->p_flag & P_STOPPED_SINGLE) != 0) { while ((p->p_flag & P_STOPPED_SINGLE) != 0) {
if ((p->p_flag2 & P2_WEXIT) != 0) if ((p->p_flag2 & P2_WEXIT) != 0)
return (1); return (1);
msleep(&p->p_flag, &p->p_mtx, PCATCH, "thrsgl", 0); msleep(&p->p_flag, &p->p_mtx, PCATCH, "thrsgl", 0);
markjUnsubmitted
Not Done
Inline Actions

So, the problem is that reap_kill_proc_locked() can block here while single-threading the debuggee? Then, shouldn't the checks come before this loop? Otherwise I do not quite understand the problem.

markj: So, the problem is that reap_kill_proc_locked() can block here while single-threading the…
kibAuthorUnsubmitted
Done
Inline Actions

This check must be atomic WRT setting the P_TOTAL_STOP flag. If done before the loop, which checks for other single-threading reasons, it would allow the race.

After the loop, we know that no other single-threading request can be active (it is blocked waiting for the process lock).

Then, the patch checks for P_TRACED so that debugger attempt to suspend all process threads (which is very similar but not covered by thread_single(), see sig_suspend_threads()) does not mess with our single-threading. This confusion, when two different suspensions (sig_suspend_threads() vs. P_TOTAL_STOP) act simultaneously, is the root cause of the reported hang.

kib: This check must be atomic WRT setting the P_TOTAL_STOP flag. If done before the loop, which…
markjUnsubmitted
Not Done
Inline Actions

I'm sorry, I just realized that my test isn't quite right, and looking again, I still don't understand the patch.

reap_kill_proc_locked() only calls thread_single() if P_STOPPED is not set in the target proc. So in particular, P_STOPPED_SINGLE is not set, so thread_single() will not drop the proc lock in the loop. I don't see how it can fix the problem reported by mjg.

markj: I'm sorry, I just realized that my test isn't quite right, and looking again, I still don't…
kibAuthorUnsubmitted
Done
Inline Actions

Why it is important is P_STOPPED_SINGLE set or not?

Let me formulate the goal of the patch differently: do not allow 'global' singlethreading (AKA singlethreading outside the process context) if the process is being debugged or stopped. The attributes of process being a debuggee is either P_TRACED or P_STOPPED_SIG flag.

kib: Why it is important is P_STOPPED_SINGLE set or not? Let me formulate the goal of the patch…
kibAuthorUnsubmitted
Done
Inline Actions

Might be, I understand your question. Mjg' issue is not a hang in the 'thrsgl' state. It is very different thing, which I called single-threading confusion between sig_suspend_threads() and P_TOTAL_STOP. Both requests utilize the same threads' state and same reporting (thread_suspend_one()), so if both come simultaneously, we might get some threads suspended due to ptracestop(), and other suspended due to single-threading. So my decision is to prevent P_STOP_ALL when the process is debugged.

Note that this is impossible to get into this state while single threading request comes from the process context.

kib: Might be, I understand your question. Mjg' issue is not a hang in the 'thrsgl' state. It is…
markjUnsubmitted
Not Done
Inline Actions

Thank you, I understand the bug better now and fixed my test case correspondingly.

markj: Thank you, I understand the bug better now and fixed my test case correspondingly.
} }
if ((p->p_flag & (P_STOPPED_SIG | P_TRACED)) != 0 ||
(p->p_flag2 & P2_WEXIT) != 0)
return (1);
} else if ((p->p_flag & P_HADTHREADS) == 0) } else if ((p->p_flag & P_HADTHREADS) == 0)
return (0); return (0);
if (p->p_singlethread != NULL && p->p_singlethread != td) if (p->p_singlethread != NULL && p->p_singlethread != td)
return (1); return (1);
if (mode == SINGLE_EXIT) { if (mode == SINGLE_EXIT) {
p->p_flag |= P_SINGLE_EXIT; p->p_flag |= P_SINGLE_EXIT;
p->p_flag &= ~P_SINGLE_BOUNDARY; p->p_flag &= ~P_SINGLE_BOUNDARY;
▲ Show 20 Lines • Show All 559 Lines • Show Last 20 Lines
View Options

astro/boinc-setiathome-v7/Makefile

Show First 20 Lines • Show All 1,240 Lines • ▼ Show 20 Linesthread_single(struct proc *p, int mode)
/* /*
* Is someone already single threading? * Is someone already single threading?
* Or may be singlethreading is not needed at all. * Or may be singlethreading is not needed at all.
*/ */
if (mode == SINGLE_ALLPROC) { if (mode == SINGLE_ALLPROC) {
while ((p->p_flag & P_STOPPED_SINGLE) != 0) { while ((p->p_flag & P_STOPPED_SINGLE) != 0) {
if ((p->p_flag2 & P2_WEXIT) != 0) if ((p->p_flag2 & P2_WEXIT) != 0)
return (1); return (1);
msleep(&p->p_flag, &p->p_mtx, PCATCH, "thrsgl", 0); msleep(&p->p_flag, &p->p_mtx, PCATCH, "thrsgl", 0);
markjUnsubmitted
Not Done
Inline Actions

So, the problem is that reap_kill_proc_locked() can block here while single-threading the debuggee? Then, shouldn't the checks come before this loop? Otherwise I do not quite understand the problem.

markj: So, the problem is that reap_kill_proc_locked() can block here while single-threading the…
kibAuthorUnsubmitted
Done
Inline Actions

This check must be atomic WRT setting the P_TOTAL_STOP flag. If done before the loop, which checks for other single-threading reasons, it would allow the race.

After the loop, we know that no other single-threading request can be active (it is blocked waiting for the process lock).

Then, the patch checks for P_TRACED so that debugger attempt to suspend all process threads (which is very similar but not covered by thread_single(), see sig_suspend_threads()) does not mess with our single-threading. This confusion, when two different suspensions (sig_suspend_threads() vs. P_TOTAL_STOP) act simultaneously, is the root cause of the reported hang.

kib: This check must be atomic WRT setting the P_TOTAL_STOP flag. If done before the loop, which…
markjUnsubmitted
Not Done
Inline Actions

I'm sorry, I just realized that my test isn't quite right, and looking again, I still don't understand the patch.

reap_kill_proc_locked() only calls thread_single() if P_STOPPED is not set in the target proc. So in particular, P_STOPPED_SINGLE is not set, so thread_single() will not drop the proc lock in the loop. I don't see how it can fix the problem reported by mjg.

markj: I'm sorry, I just realized that my test isn't quite right, and looking again, I still don't…
kibAuthorUnsubmitted
Done
Inline Actions

Why it is important is P_STOPPED_SINGLE set or not?

Let me formulate the goal of the patch differently: do not allow 'global' singlethreading (AKA singlethreading outside the process context) if the process is being debugged or stopped. The attributes of process being a debuggee is either P_TRACED or P_STOPPED_SIG flag.

kib: Why it is important is P_STOPPED_SINGLE set or not? Let me formulate the goal of the patch…
kibAuthorUnsubmitted
Done
Inline Actions

Might be, I understand your question. Mjg' issue is not a hang in the 'thrsgl' state. It is very different thing, which I called single-threading confusion between sig_suspend_threads() and P_TOTAL_STOP. Both requests utilize the same threads' state and same reporting (thread_suspend_one()), so if both come simultaneously, we might get some threads suspended due to ptracestop(), and other suspended due to single-threading. So my decision is to prevent P_STOP_ALL when the process is debugged.

Note that this is impossible to get into this state while single threading request comes from the process context.

kib: Might be, I understand your question. Mjg' issue is not a hang in the 'thrsgl' state. It is…
markjUnsubmitted
Not Done
Inline Actions

Thank you, I understand the bug better now and fixed my test case correspondingly.

markj: Thank you, I understand the bug better now and fixed my test case correspondingly.
} }
if ((p->p_flag & (P_STOPPED_SIG | P_TRACED)) != 0 ||
(p->p_flag2 & P2_WEXIT) != 0)
return (1);
} else if ((p->p_flag & P_HADTHREADS) == 0) } else if ((p->p_flag & P_HADTHREADS) == 0)
return (0); return (0);
if (p->p_singlethread != NULL && p->p_singlethread != td) if (p->p_singlethread != NULL && p->p_singlethread != td)
return (1); return (1);
if (mode == SINGLE_EXIT) { if (mode == SINGLE_EXIT) {
p->p_flag |= P_SINGLE_EXIT; p->p_flag |= P_SINGLE_EXIT;
p->p_flag &= ~P_SINGLE_BOUNDARY; p->p_flag &= ~P_SINGLE_BOUNDARY;
▲ Show 20 Lines • Show All 559 Lines • Show Last 20 Lines
View Options

astro/boinc-setiathome-v7/distinfo

Loading...
View Options

astro/boinc-setiathome-v7/files/

Loading...
View Options

astro/boinc-setiathome-v7/files/patch-client_Makefile.am

Loading...
View Options

astro/boinc-setiathome-v7/files/patch-client_vector_analyzeFuncs__sse.cpp

Loading...
View Options

astro/boinc-setiathome-v7/files/patch-client_vector_analyzeFuncs__vector.cpp

Loading...
View Options

astro/boinc-setiathome-v7/files/patch-client_vector_analyzeFuncs__x86__64.cpp

Loading...
View Options

astro/boinc-setiathome-v7/files/patch-client_vector_x86__float4.h

Loading...
View Options

astro/boinc-setiathome-v7/files/patch-client_vector_x86__ops.h

Loading...
View Options

astro/boinc-setiathome-v7/files/patch-configure.ac

Loading...
View Options

astro/boinc-setiathome-v7/files/patch-m4_sah__check__boinc.m4

Loading...
View Options

astro/boinc-setiathome-v7/files/patch-sah__config.h

Loading...
View Options

astro/boinc-setiathome-v7/files/pkg-deinstall.in

Loading...
View Options

astro/boinc-setiathome-v7/files/pkg-install.in

Loading...
View Options

astro/boinc-setiathome-v7/files/pkg-message.in

Loading...
View Options

astro/boinc-setiathome-v7/pkg-descr

Loading...
View Options

astro/boinc-setiathome-v7/pkg-plist

Loading...
View Options

sysutils/rundeck/Makefile

Loading...
View Options

sysutils/rundeck/pkg-plist

Loading...