From: Roland McGrath <hidden> Date: 2009-10-13 23:55:10
My only concern is the support of 64-bit clone flags on 32-bit architectures.
Oy. I didn't realize there was serious consideration of having more than
32 flags. IMHO it would be a bad choice, since they could only be used via
clone3. Having high-bit flags work in clone on 64-bit machines but not on
32-bit machines just seems like a wrongly confusing way for things to be.
If any high-bits flags are constrained even on 64-bit machines to uses in
clone3 calls for sanity purposes, then it seems questionable IMHO to have
them be more flags in the same u64 at all.
Since all new features will be via this struct, various new kinds of things
could potentially be done by other new struct fields independent of flags.
But that would of course require putting enough reserved fields in now and
requiring that they be zero-filled now in anticipation of such future uses,
which is not very pleasant either.
In short, I guess I really am saying that "clone_flags_high" (or
"more_flags" or something) does seem better to me than any of the
possibilities for having more than 32 CLONE_* in the current flags word.
Thanks,
Roland
From: "H. Peter Anvin" <hpa@zytor.com> Date: 2009-10-14 01:24:45
On 10/13/2009 04:53 PM, Roland McGrath wrote:
quoted
My only concern is the support of 64-bit clone flags on 32-bit architectures.
Oy. I didn't realize there was serious consideration of having more than
32 flags. IMHO it would be a bad choice, since they could only be used via
clone3. Having high-bit flags work in clone on 64-bit machines but not on
32-bit machines just seems like a wrongly confusing way for things to be.
If any high-bits flags are constrained even on 64-bit machines to uses in
clone3 calls for sanity purposes, then it seems questionable IMHO to have
them be more flags in the same u64 at all.
Since all new features will be via this struct, various new kinds of things
could potentially be done by other new struct fields independent of flags.
But that would of course require putting enough reserved fields in now and
requiring that they be zero-filled now in anticipation of such future uses,
which is not very pleasant either.
In short, I guess I really am saying that "clone_flags_high" (or
"more_flags" or something) does seem better to me than any of the
possibilities for having more than 32 CLONE_* in the current flags word.
Overall it seems sane to:
a) make it an actual 3-argument call;
b) make the existing flags a u32 forever, and make it a separate
argument;
c) any new expansion can be via the struct, which may want to have
an "c3_flags" field first in the structure.
-hpa
--
H. Peter Anvin, Intel Open Source Technology Center
I work for Intel. I don't speak on their behalf.
H. Peter Anvin [hpa-YMNOUZJC4hwAvxtiuMwx3w@public.gmane.org] wrote:
| On 10/13/2009 04:53 PM, Roland McGrath wrote:
| >> My only concern is the support of 64-bit clone flags on 32-bit architectures.
| >
| > Oy. I didn't realize there was serious consideration of having more than
| > 32 flags. IMHO it would be a bad choice, since they could only be used via
| > clone3. Having high-bit flags work in clone on 64-bit machines but not on
| > 32-bit machines just seems like a wrongly confusing way for things to be.
| > If any high-bits flags are constrained even on 64-bit machines to uses in
| > clone3 calls for sanity purposes, then it seems questionable IMHO to have
| > them be more flags in the same u64 at all.
| >
| > Since all new features will be via this struct, various new kinds of things
| > could potentially be done by other new struct fields independent of flags.
| > But that would of course require putting enough reserved fields in now and
| > requiring that they be zero-filled now in anticipation of such future uses,
| > which is not very pleasant either.
| >
| > In short, I guess I really am saying that "clone_flags_high" (or
| > "more_flags" or something) does seem better to me than any of the
| > possibilities for having more than 32 CLONE_* in the current flags word.
| >
|
| Overall it seems sane to:
|
| a) make it an actual 3-argument call;
| b) make the existing flags a u32 forever, and make it a separate
| argument;
| c) any new expansion can be via the struct, which may want to have
| an "c3_flags" field first in the structure.
Wouldn't that make it a somewhat awkward interface - applications or
libc have to split the clone flags and specify them in two different
fields ? Do we need to preserve the u32 flags forever ?
The closest example I can think of is the distinction between signal()
and sigaction(). sigaction() interface makes a lot of sense in part bc
it does not try to look like signal(). And strace seems to be able
decode flags like SA_RESTART and SA_SIGINFO with the pointer to the
sigaction buffer.
Won't the debug tools be able to do the same with a pointer to
struct clone_args ?
If it needs the new features of clone3(), the application has to be
modified. At that point wouldn't it be easy to write a clone3() wrapper
that calls sys_clone3() if it exists or call sys_clone() if not ?
If clone3() supersedes clone(), all architectures could use the clone3()
interface and it would seem best to make clone3() as simple as possible
without having to preserve the u32 flags.
Would it help to use a type clone_flags_64_t to make the distinction
between types more explicit ?
Sukadev
From: "H. Peter Anvin" <hpa@zytor.com> Date: 2009-10-14 04:50:21
On 10/13/2009 09:36 PM, Sukadev Bhattiprolu wrote:
Would it help to use a type clone_flags_64_t to make the distinction
between types more explicit ?
The problem with using the same flags in two places, one as a 32-bit and
one as a 64-bit number, is that using one in the wrong place will cause
silent, but deadly, truncation.
-hpa
--
H. Peter Anvin, Intel Open Source Technology Center
I work for Intel. I don't speak on their behalf.
H. Peter Anvin [hpa-YMNOUZJC4hwAvxtiuMwx3w@public.gmane.org] wrote:
| On 10/13/2009 04:53 PM, Roland McGrath wrote:
| >> My only concern is the support of 64-bit clone flags on 32-bit architectures.
| >
| > Oy. I didn't realize there was serious consideration of having more than
| > 32 flags. IMHO it would be a bad choice, since they could only be used via
| > clone3. Having high-bit flags work in clone on 64-bit machines but not on
| > 32-bit machines just seems like a wrongly confusing way for things to be.
| > If any high-bits flags are constrained even on 64-bit machines to uses in
| > clone3 calls for sanity purposes, then it seems questionable IMHO to have
| > them be more flags in the same u64 at all.
| >
| > Since all new features will be via this struct, various new kinds of things
| > could potentially be done by other new struct fields independent of flags.
| > But that would of course require putting enough reserved fields in now and
| > requiring that they be zero-filled now in anticipation of such future uses,
| > which is not very pleasant either.
| >
| > In short, I guess I really am saying that "clone_flags_high" (or
| > "more_flags" or something) does seem better to me than any of the
| > possibilities for having more than 32 CLONE_* in the current flags word.
| >
|
| Overall it seems sane to:
|
| a) make it an actual 3-argument call;
| b) make the existing flags a u32 forever, and make it a separate
| argument;
| c) any new expansion can be via the struct, which may want to have
| an "c3_flags" field first in the structure.
Ok, So will this work ?
struct clone_args {
u32 flags_high; /* new clone flags (higher bits) */
u32 reserved1;
u32 nr_pids;
u32 reserved2;
u64 child_stack_base;
u64 child_stack_size;
u64 parent_tid_ptr;
u64 child_tid_ptr;
u64 reserved3;
};
sys_clone3(u32 flags_low, struct clone_args *args, pid_t *pid_list)
Even on 64bit architectures the applications have to use sys_clone3() for
the extended features.
From: "H. Peter Anvin" <hpa@zytor.com> Date: 2009-10-14 23:03:28
On 10/14/2009 03:36 PM, Sukadev Bhattiprolu wrote:
H. Peter Anvin [hpa-YMNOUZJC4hwAvxtiuMwx3w@public.gmane.org] wrote:
|
| Overall it seems sane to:
|
| a) make it an actual 3-argument call;
| b) make the existing flags a u32 forever, and make it a separate
| argument;
| c) any new expansion can be via the struct, which may want to have
| an "c3_flags" field first in the structure.
Ok, So will this work ?
struct clone_args {
u32 flags_high; /* new clone flags (higher bits) */
u32 reserved1;
u32 nr_pids;
u32 reserved2;
u64 child_stack_base;
u64 child_stack_size;
u64 parent_tid_ptr;
u64 child_tid_ptr;
u64 reserved3;
};
sys_clone3(u32 flags_low, struct clone_args *args, pid_t *pid_list)
Even on 64bit architectures the applications have to use sys_clone3() for
the extended features.
Yes, although I'd just make flags_high a u64. The other thing that
might be worthwhile is to have a length field on the structure; that way
we could add new fields at the end if ever necessary in the future.
-hpa
H. Peter Anvin [hpa-YMNOUZJC4hwAvxtiuMwx3w@public.gmane.org] wrote:
| On 10/14/2009 03:36 PM, Sukadev Bhattiprolu wrote:
| > H. Peter Anvin [hpa-YMNOUZJC4hwAvxtiuMwx3w@public.gmane.org] wrote:
| > |
| > | Overall it seems sane to:
| > |
| > | a) make it an actual 3-argument call;
| > | b) make the existing flags a u32 forever, and make it a separate
| > | argument;
| > | c) any new expansion can be via the struct, which may want to have
| > | an "c3_flags" field first in the structure.
| >
| > Ok, So will this work ?
| >
| > struct clone_args {
| > u32 flags_high; /* new clone flags (higher bits) */
| > u32 reserved1;
| > u32 nr_pids;
| > u32 reserved2;
| > u64 child_stack_base;
| > u64 child_stack_size;
| > u64 parent_tid_ptr;
| > u64 child_tid_ptr;
| > u64 reserved3;
| > };
| >
| > sys_clone3(u32 flags_low, struct clone_args *args, pid_t *pid_list)
| >
| > Even on 64bit architectures the applications have to use sys_clone3() for
| > the extended features.
|
| Yes, although I'd just make flags_high a u64.
so we allow 96 bits for flags ?
| The other thing that might be worthwhile is to have a length field on
| the structure; that way we could add new fields at the end if ever
| necessary in the future.
So:
struct clone_args {
u64 flags_high; /* new clone flags (higher bits) */
u64 reserved1;
u32 nr_pids;
u32 clone_args_size;
u64 child_stack_base;
u64 child_stack_size;
u64 parent_tid_ptr;
u64 child_tid_ptr;
};
sys_clone3(u32 flags_low, struct clone_args *args, pid_t *pid_list)
BTW, on 64-bit architectures, the flags_low would be 64-bits, but the high-
bits there would be ignored right ?
Not sure if we need a second reserved field now that we add ->clone_args_size.
Thanks,
Sukadev