Minutes 2022-05-19 meeting

[annevk]

We had a call to discuss #21 synchronously. Apologies for not announcing it here ahead of time as per https://whatwg.org/working-mode#meetings, though rest assured that nothing from the meeting is binding.

• Add Access Handles to spec #21, rendered: https://whatpr.org/fs/21.html

• Randell: odd that async AccessHandle is missing

  • Emanuel: needs more community discussion, but I’d be happy to move forward with the tentative proposal we have.
  • Austin: it’s something we want to add. We might also want to deprecate sync AccessHandle…
  • Randell: it’s a bit odd to specify them and then immediately deprecate.
  • Emanuel: I suspect that’ll take a long time, especially given where Wasm is at.

• Randell: on sync AccessHandle, why are some accessors async?

  • Emanuel: context is that there’s sorta two sides. Wasm wants synchronous. Web API designers prefer less synchronous APIs.
  • Randell: sounds reasonable for compat with the future async AccessHandle.
  • Anne: does it queue a task?
  • Austin: it should.
  • ACTION: Anne to raise this as a spec comment.

• Randell: how is quota supposed to be handled?

  • Austin: in our impl the write would fail due to quota limits.
  • Emanuel: write() can fail due to quota limits if you write beyond the file size. And truncate() can fail if you increase the file size.
  • Randell: how do you deal with partial writes?
  • Emanuel: in principle quota is checked upfront and we reject upon reaching the limit, if it’s within the limit but the write failed anyway, number of successfully written bytes are returned.
  • Randell: I think it’s important that if you have written something, you return a number. Otherwise the application has to assume the file is hosed.
  • ACTION: Emanuel to make sure this is in the spec.
  • ACTION: Google to ensure it’s what they implemented.

• Randell: I think the locking concern got resolved.

• Emanuel: there were a couple of changes we were discussing internally I’d like to bring up.

  • Reading and writing takes a non-optional options parameter. I would like to make that parameter optional.
  • ACTION: Emanuel to fix the spec.

• Emanuel: how to deal with SAB and races

  • Anne: not my area of expertise, but from what I recall this might be UB in C++. Henri Sivonen would be a good person to ask.
  • ACTION: Everyone to ask around internally to sort out what’s best here.

• Randell: AOB?

  • Randell: is there anything we might run into?
  • Emanuel: I don’t think anyone relies on a scary corner case. I think it should work once you implement it.

• Randell: how much quota do applications expect?

  • Austin: in Chrome we allow any site up to 60% of your disk.
  • Randell: I believe we are more conservative.

• Anne: not sure we raised this, but what about “valid file name”? How does that work for OPFS?

  • There’s also a problem with long paths on Windows.
  • Randell: thus far we hash things and store names in a side table.
  • Austin: that matches our implementation.
  • ACTION: Randell to file an issue on file names.

• Anne: publish minutes in an issue? [Agreement]

• Austin: there’s also PRs for remove/move and need locking.

  • Randell: exclusive locks I assume?
  • Austin: yup.
  • Randell: if we add move, we should also specify the implications for existing handles to that file.
  • Anne: I think it requires making it more explicit that handles are essentially paths.
  • Austin: need to talk to Marijn.
  • ACTION: Austin to talk to Marijn and sort out behavior of handles.

[dslee414]

Looks like most action items listed here are completed. One question I have is -- what does SAB mean?

[a-sully]

SharedArrayBuffer. I don't exactly remember what these discussions around SAB were about... Does anyone else remember / have any updates?

[annevk]

I think we might be okay. The specific problem that might be UB with shared memory as I understood it from @hsivonen is if you have JS and C++ accessing the shared memory at the same time, JS manipulating it, and C++ using it for something. However, all we have is "write into buffer" and "copy from buffer". So I think we're okay.