On Mon, Feb 19, 2024 at 09:26:25AM -0500, James Bottomley wrote: > On Sat, 2024-02-17 at 15:56 -0500, Kent Overstreet wrote: > > AKA - integer identifiers considered harmful > > > > Any time you've got a namespace that's just integers, if you ever end > > up needing to subdivide it you're going to have a bad time. > > > > This comes up all over the place - for another example, consider > > ioctl numbering, where keeping them organized and collision free is a > > major headache. > > > > For UIDs, we need to be able to subdivide the UID namespace for e.g. > > containers and mounting filesystems as an unprivileged user - but > > since we just have an integer identifier, this requires complicated > > remapping and updating and maintaining a global table. > > > > Subdividing a UID to create new permissions domains should be a > > cheap, easy operation, and it's not. > > > > The solution (originally from plan9, of course) is - UIDs shouldn't > > be numbers, they should be strings; and additionally, the strings > > should be paths. > > > > Then, if 'alice' is a user, 'alice.foo' and 'alice.bar' would be > > subusers, created by alice without any privileged operations or > > mucking with outside system state, and 'alice' would be superuser > > w.r.t. 'alice.foo' and 'alice.bar'. > > > > What's this get us? > > I would have to say that changing kuid for a string doesn't really buy > us anything except a load of complexity for no very real gain. > However, since the current kuid is u32 and exposed uid is u16 and there > is already a proposal to make use of this somewhat in the way you > envision, Got a link to that proposal? > there might be a possibility to re-express kuid as an array > of u16s without much disruption. Each adjacent pair could represent > the owner at the top and the userns assigned uid underneath. That > would neatly solve the nesting problem the current upper 16 bits > proposal has. At a high level, there's no real difference between a variable length integer, or a variable length array of integers, or a string. But there's real advantages to getting rid of the string <-> integer identifier mapping and plumbing strings all the way through: - creating a new sub-user can be done with nothing more than the new username version of setuid(); IOW, we can start a new named subuser for e.g. firefox without mucking with _any_ system state or tables - sharing filesystems between machines is always a pita because usernames might be the same but uids never are - let's kill that off, please Doing anything as big as an array of integers is going to be a major compatibiltiy break anyways, so we might as well do it right. Either way we're going to need a mapping to 16 bit uids for compatibility; doing this right gives userspace an incentive to get _off_ that compatibility layer so we're not dealing with that impedence mismatch forever. > However, neither proposal would get us out of the problem of mount > mapping because we'd have to keep the filesystem permission check on > the owning uid unless told otherwise. Not sure I follow? We're always going to need mount mapping, but if the mount mapping is just "usernames here get mapped to this subtree of the system username namespace", then that potentially simplifies things quite a bit - the mount mapping is no longer a _table_. And it wouldn't have to be administrator assigned. Some administrator assignment might be required for the username <-> 16 bit uid mapping, but if those mappings are ephemeral (i.e. if we get filesystems persistently storing usernames, which is easy enough with xattrs) then that just becomes "reserve x range of the 16 bit uid space for ephemeral translations".
