@samitouri / QOSAMI-WSL / commits / 31331371

Fix various issues around initial tty sizes + add test coverage (#40722)

* Save state * Save state * Prepare for PR * Cleanup diff * Cleanup diff * Save state * Rethink tests * Apply PR feedback

Blue committed Jun 9, 2026 at 11:37 UTC 313313718dad1c934c0ba02ec4643c7e486f746e

30 files changed +443 -93

src/windows/common/ConsoleState.cpp

+29 -14

@@ -64,12 +64,33 @@ namespace wsl::windows::common {

65 ConsoleState::ConsoleState()

66 {

67 - // Ensure console state is restored if the constructor throws.

68 - auto cleanup = wil::scope_exit_log(WI_DIAGNOSTICS_INFO, [&]() { RestoreConsoleState(); });

69 -

67 m_InputHandle.reset(

68 CreateFileW(L"CONIN$", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, 0, nullptr));

70 + if (!m_InputHandle)

71 + {

72 + LOG_LAST_ERROR_MSG("CreateFileW(CONIN$) failed");

73 + }

74 +

75 + m_OutputHandle.reset(

76 + CreateFileW(L"CONOUT$", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, 0, nullptr));

77 +

78 + if (!m_OutputHandle)

79 + {

80 + LOG_LAST_ERROR_MSG("CreateFileW(CONOUT$) failed");

81 + }

82 +}

83 +

84 +void ConsoleState::SetInteractiveMode()

85 +{

86 + if (m_interactiveModeConfigured)

87 + {

88 + return;

89 + }

90 +

91 + // Ensure console state is restored if this method throws.

92 + auto cleanup = wil::scope_exit_log(WI_DIAGNOSTICS_INFO, [&]() { RestoreConsoleState(); });

93 +

94 if (m_InputHandle)

95 {

96 m_SavedInputCodePage = GetConsoleCP();

@@ -85,13 +106,6 @@ ConsoleState::ConsoleState()

106 ChangeConsoleMode(m_InputHandle.get(), NewMode);

107 m_SavedInputMode = mode;

108 }

88 - else

89 - {

90 - LOG_LAST_ERROR_MSG("CreateFileW(CONIN$) failed");

91 - }

92 -

93 - m_OutputHandle.reset(

94 - CreateFileW(L"CONOUT$", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, 0, nullptr));

109

110 if (m_OutputHandle)

111 {

@@ -107,11 +121,8 @@ ConsoleState::ConsoleState()

121 ChangeConsoleMode(m_OutputHandle.get(), NewMode);

122 m_SavedOutputMode = mode;

123 }

110 - else

111 - {

112 - LOG_LAST_ERROR_MSG("CreateFileW(CONOUT$) failed");

113 - }

124

125 + m_interactiveModeConfigured = true;

126 cleanup.release();

127 }

128

@@ -127,11 +138,13 @@ void ConsoleState::RestoreConsoleState()

138 if (m_SavedInputCodePage.has_value())

139 {

140 LOG_IF_WIN32_BOOL_FALSE(SetConsoleCP(m_SavedInputCodePage.value()));

141 + m_SavedInputCodePage.reset();

142 }

143

144 if (m_SavedInputMode.has_value())

145 {

146 TrySetConsoleMode(m_InputHandle.get(), m_SavedInputMode.value());

147 + m_SavedInputMode.reset();

148 }

149 }

150

@@ -140,11 +153,13 @@ void ConsoleState::RestoreConsoleState()

153 if (m_SavedOutputCodePage.has_value())

154 {

155 LOG_IF_WIN32_BOOL_FALSE(SetConsoleOutputCP(m_SavedOutputCodePage.value()));

156 + m_SavedOutputCodePage.reset();

157 }

158

159 if (m_SavedOutputMode.has_value())

160 {

161 TrySetConsoleMode(m_OutputHandle.get(), m_SavedOutputMode.value());

162 + m_SavedOutputMode.reset();

163 }

164 }

165 }

src/windows/common/ConsoleState.h

@@ -32,12 +32,14 @@ public:

32 ConsoleState& operator=(ConsoleState&&) = delete;

34 COORD GetWindowSize() const;

35 + void SetInteractiveMode();

37 private:

38 void RestoreConsoleState();

40 wil::unique_hfile m_InputHandle;

41 wil::unique_hfile m_OutputHandle;

42 + bool m_interactiveModeConfigured{false};

43 std::optional<DWORD> m_SavedInputMode{};

44 std::optional<UINT> m_SavedInputCodePage{};

45 std::optional<DWORD> m_SavedOutputMode{};

src/windows/common/WSLCContainerLauncher.cpp

+5 -1

@@ -259,7 +259,11 @@ std::pair<HRESULT, std::optional<RunningWSLCContainer>> WSLCContainerLauncher::L

259 return std::make_pair(result, std::optional<RunningWSLCContainer>{});

260 }

261

262 - result = container.value().Get().Start(Flags, nullptr, WarningCallback);

262 + WSLCProcessStartOptions startOptions{};

263 + startOptions.TtyRows = m_rows;

264 + startOptions.TtyColumns = m_columns;

265 +

266 + result = container.value().Get().Start(Flags, &startOptions, WarningCallback);

267

268 return std::make_pair(result, std::move(container));

269 }

src/windows/common/WSLCContainerLauncher.h

@@ -86,6 +86,7 @@ public:

86 void AddUlimit(const std::string& Name, std::int64_t Soft, std::int64_t Hard);

88 using WSLCProcessLauncher::FormatResult;

89 + using WSLCProcessLauncher::SetTtySize;

90 using WSLCProcessLauncher::SetUser;

91 using WSLCProcessLauncher::SetWorkingDirectory;

src/windows/common/WSLCProcessLauncher.cpp

+7 -4

@@ -57,8 +57,6 @@ std::tuple<WSLCProcessOptions, std::vector<const char*>, std::vector<const char*

57 WSLCProcessOptions options{};

58 options.CommandLine = {.Values = commandLine.data(), .Count = static_cast<DWORD>(commandLine.size())};

59 options.Environment = {.Values = environment.data(), .Count = static_cast<DWORD>(environment.size())};

60 - options.TtyColumns = m_columns;

61 - options.TtyRows = m_rows;

60 options.Flags = m_flags;

62 if (!m_workingDirectory.empty())

@@ -182,7 +180,7 @@ std::tuple<HRESULT, std::optional<ClientRunningWSLCProcess>, int> WSLCProcessLau

180

181 wil::com_ptr<IWSLCProcess> process;

182 int error = -1;

185 - auto result = Session.CreateRootNamespaceProcess(m_executable.c_str(), &options, &process, &error);

183 + auto result = Session.CreateRootNamespaceProcess(m_executable.c_str(), &options, m_rows, m_columns, &process, &error);

184 if (FAILED(result))

185 {

186 return std::make_tuple(result, std::optional<ClientRunningWSLCProcess>(), error);

@@ -198,7 +196,12 @@ std::tuple<HRESULT, std::optional<ClientRunningWSLCProcess>> WSLCProcessLauncher

196 auto [options, commandLine, env] = CreateProcessOptions();

197

198 wil::com_ptr<IWSLCProcess> process;

201 - auto result = Container.Exec(&options, m_detachKeys.has_value() ? m_detachKeys->c_str() : nullptr, &process);

199 + WSLCProcessStartOptions startOptions{};

200 + startOptions.TtyRows = m_rows;

201 + startOptions.TtyColumns = m_columns;

202 + startOptions.DetachKeys = m_detachKeys.has_value() ? m_detachKeys->c_str() : nullptr;

203 +

204 + auto result = Container.Exec(&options, &startOptions, &process);

205 if (FAILED(result))

206 {

207 return std::make_pair(result, std::optional<ClientRunningWSLCProcess>());

src/windows/common/WSLCProcessLauncher.h

+3 -3

@@ -109,8 +109,8 @@ protected:

109 std::optional<std::string> m_detachKeys;

110 std::vector<std::string> m_arguments;

111 std::vector<std::string> m_environment;

112 - DWORD m_rows = 0;

113 - DWORD m_columns = 0;

112 + DWORD m_rows = 24;

113 + DWORD m_columns = 80;

114 };

115

116 -} // namespace wsl::windows::common

\ No newline at end of file

116 +} // namespace wsl::windows::common

src/windows/common/WslClient.cpp

@@ -1501,6 +1501,7 @@ int RunDebugShell()

1501

1502 // Create a thread to relay stdin to the pipe.

1503 wsl::windows::common::ConsoleState console;

1504 + console.SetInteractiveMode();

1505 auto exitEvent = wil::unique_event(wil::EventOptions::ManualReset);

1506 std::thread inputThread([&]() {

1507 wsl::windows::common::relay::StandardInputRelay(GetStdHandle(STD_INPUT_HANDLE), pipe.get(), []() {}, exitEvent.get());

src/windows/common/svccomm.cpp

@@ -294,6 +294,7 @@ wsl::windows::common::SvcComm::LaunchProcess(

294 //

295

296 ConsoleState Io;

297 + Io.SetInteractiveMode();

298 COORD WindowSize = Io.GetWindowSize();

299 ULONG Flags = LXSS_CREATE_INSTANCE_FLAGS_ALLOW_FS_UPGRADE;

300 if (WI_IsFlagSet(LaunchFlags, LXSS_LAUNCH_FLAG_USE_SYSTEM_DISTRO))

src/windows/service/exe/PluginManager.cpp

+1 -1

@@ -197,7 +197,7 @@ try

197

198 wil::com_ptr<IWSLCProcess> process;

199 int errnoValue = 0;

200 - auto result = session->CreateRootNamespaceProcess(Executable, &options, &process, &errnoValue);

200 + auto result = session->CreateRootNamespaceProcess(Executable, &options, 0, 0, &process, &errnoValue);

201

202 if (Errno != nullptr)

203 {

src/windows/service/inc/wslc.idl

+9 -4

@@ -221,9 +221,14 @@ typedef struct _WSLCProcessOptions

221 WSLCStringArray CommandLine;

222 WSLCStringArray Environment;

223 WSLCProcessFlags Flags;

224 +} WSLCProcessOptions;

225 +

226 +typedef struct _WSLCProcessStartOptions

227 +{

228 ULONG TtyRows; // Only needed when tty fd's are passed.

229 ULONG TtyColumns;

226 -} WSLCProcessOptions;

230 + [unique, string] LPCSTR DetachKeys;

231 +} WSLCProcessStartOptions;

232

233 typedef struct _WSLCNamedVolume

234 {

@@ -574,12 +579,12 @@ interface IWSLCContainer : IUnknown

579 {

580 HRESULT Attach([in, unique] LPCSTR DetachKeys, [out] WSLCHandle* StdIn, [out] WSLCHandle* StdOut, [out] WSLCHandle* StdErr);

581 HRESULT Stop([in] WSLCSignal Signal, [in] LONG TimeoutSeconds);

577 - HRESULT Start([in] WSLCContainerStartFlags Flags, [in, unique] LPCSTR DetachKeys, [in, unique] IWarningCallback* WarningCallback);

582 + HRESULT Start([in] WSLCContainerStartFlags Flags, [in, unique] const WSLCProcessStartOptions* StartOptions, [in, unique] IWarningCallback* WarningCallback);

583 HRESULT Delete([in] WSLCDeleteFlags Flags);

584 HRESULT Export([in] WSLCHandle TarHandle);

585 HRESULT GetState([out] WSLCContainerState* State);

586 HRESULT GetInitProcess([out] IWSLCProcess** Process);

582 - HRESULT Exec([in, ref] const WSLCProcessOptions* Options, [in, unique] LPCSTR DetachKeys, [out] IWSLCProcess** Process);

587 + HRESULT Exec([in, ref] const WSLCProcessOptions* Options, [in, unique] const WSLCProcessStartOptions* StartOptions, [out] IWSLCProcess** Process);

588 HRESULT Inspect([out] LPSTR* Output);

589 HRESULT Logs([in] WSLCLogsFlags Flags, [out] WSLCHandle* Stdout, [out] WSLCHandle* Stderr, [in] ULONGLONG Since, [in] ULONGLONG Until, [in] ULONGLONG Tail);

590 HRESULT GetId([out, string] WSLCContainerId Id);

@@ -763,7 +768,7 @@ interface IWSLCSession : IUnknown

768 HRESULT PruneContainers([in, unique, size_is(FiltersCount)] const WSLCFilter* Filters, [in] ULONG FiltersCount, [out] WSLCPruneContainersResults* Result);

769

770 // Create a process at the VM level. This is meant for debugging.

766 - HRESULT CreateRootNamespaceProcess([in, ref] LPCSTR Executable, [in, ref] const WSLCProcessOptions* Options, [out] IWSLCProcess** Process, [out] int* Errno);

771 + HRESULT CreateRootNamespaceProcess([in, ref] LPCSTR Executable, [in, ref] const WSLCProcessOptions* Options, [in] ULONG TtyRows, [in] ULONG TtyColumns, [out] IWSLCProcess** Process, [out] int* Errno);

772

773 // TODO: an OpenProcess() method can be added later if needed.

774

src/windows/wslc/services/ConsoleService.cpp

+5 -5

@@ -21,10 +21,10 @@ using wsl::windows::common::ClientRunningWSLCProcess;

21 using wsl::windows::common::io::ReadHandle;

22 using wsl::windows::common::io::RelayHandle;

24 -bool ConsoleService::RelayInteractiveTty(ClientRunningWSLCProcess& Process, HANDLE Tty, bool triggerRefresh)

24 +bool ConsoleService::RelayInteractiveTty(wsl::windows::common::ConsoleState& console, ClientRunningWSLCProcess& Process, HANDLE Tty, bool triggerRefresh)

25 {

26 - // Configure console for interactive usage.

27 - wsl::windows::common::ConsoleState console;

26 + // Configure the console for interactive usage.

27 + console.SetInteractiveMode();

29 if (triggerRefresh)

30 {

@@ -108,11 +108,11 @@ void ConsoleService::RelayNonTtyProcess(wil::unique_handle&& Stdin, wil::unique_

108 io.Run({});

109 }

110

111 -int ConsoleService::AttachToCurrentConsole(wsl::windows::common::ClientRunningWSLCProcess&& process)

111 +int ConsoleService::AttachToCurrentConsole(wsl::windows::common::ConsoleState& console, wsl::windows::common::ClientRunningWSLCProcess&& process, bool triggerRefresh)

112 {

113 if (WI_IsFlagSet(process.Flags(), WSLCProcessFlagsTty))

114 {

115 - if (!RelayInteractiveTty(process, process.GetStdHandle(WSLCFDTty).get()))

115 + if (!RelayInteractiveTty(console, process, process.GetStdHandle(WSLCFDTty).get(), triggerRefresh))

116 {

117 wsl::windows::common::wslutil::PrintMessage(L"[detached]", stderr);

118 return 0;

src/windows/wslc/services/ConsoleService.h

+5 -2

@@ -15,13 +15,16 @@ Abstract:

16 #include <wslc.h>

17 #include <WSLCContainerLauncher.h>

18 +#include <ConsoleState.h>

20 namespace wsl::windows::wslc::services {

21 class ConsoleService

22 {

23 public:

23 - static int AttachToCurrentConsole(wsl::windows::common::ClientRunningWSLCProcess&& process);

24 - static bool RelayInteractiveTty(wsl::windows::common::ClientRunningWSLCProcess& process, HANDLE tty, bool triggerRefresh = false);

24 + static int AttachToCurrentConsole(

25 + wsl::windows::common::ConsoleState& console, wsl::windows::common::ClientRunningWSLCProcess&& process, bool triggerRefresh = false);

26 + static bool RelayInteractiveTty(

27 + wsl::windows::common::ConsoleState& console, wsl::windows::common::ClientRunningWSLCProcess& process, HANDLE tty, bool triggerRefresh = false);

28 static void RelayNonTtyProcess(wil::unique_handle&& Stdin, wil::unique_handle&& Stdout, wil::unique_handle&& Stderr);

29 };

30 } // namespace wsl::windows::wslc::services

src/windows/wslc/services/ContainerService.cpp

+37 -9

@@ -20,6 +20,7 @@ Abstract:

20 #include "WarningCallback.h"

21 #include <wslutil.h>

22 #include <WSLCProcessLauncher.h>

23 +#include <ConsoleState.h>

24 #include <CommandLine.h>

25 #include <filesystem>

26 #include <unordered_map>

@@ -292,7 +293,8 @@ int ContainerService::Attach(Session& session, const std::string& id)

293 {

294 // TTY process - relay using interactive TTY handling

295 WI_ASSERT(stderrLogs.Empty());

295 - if (!ConsoleService::RelayInteractiveTty(runningProcess, stdinLogs.Release().get(), true))

296 + wsl::windows::common::ConsoleState console;

297 + if (!ConsoleService::RelayInteractiveTty(console, runningProcess, stdinLogs.Release().get(), true))

298 {

299 wsl::windows::common::wslutil::PrintMessage(L"[detached]", stderr);

300 return 0; // Exit early if user detached

@@ -382,17 +384,29 @@ int ContainerService::Run(Session& session, const std::string& image, ContainerO

384 // Start the created container

385 WSLCContainerStartFlags startFlags{};

386 WI_SetFlagIf(startFlags, WSLCContainerStartFlagsAttach, !runOptions.Detach);

385 - THROW_IF_FAILED(container.Start(startFlags, nullptr, warningCallback.Get())); // TODO: Error message, detach keys

387 +

388 + const bool attach = WI_IsFlagSet(startFlags, WSLCContainerStartFlagsAttach);

389 +

390 + wsl::windows::common::ConsoleState console;

391 + WSLCProcessStartOptions startOptions{};

392 + if (runOptions.TTY)

393 + {

394 +

395 + const auto size = console.GetWindowSize();

396 + startOptions.TtyRows = size.Y;

397 + startOptions.TtyColumns = size.X;

398 + }

399 +

400 + THROW_IF_FAILED(container.Start(startFlags, &startOptions, warningCallback.Get())); // TODO: detach keys

401

402 // Disable auto-delete only after successful start

403 runningContainer.SetDeleteOnClose(false);

404 cidFile.Commit(containerId);

405

406 // Handle attach if requested

392 - if (WI_IsFlagSet(startFlags, WSLCContainerStartFlagsAttach))

407 + if (attach)

408 {

394 - ConsoleService consoleService;

395 - return consoleService.AttachToCurrentConsole(runningContainer.GetInitProcess());

409 + return ConsoleService::AttachToCurrentConsole(console, runningContainer.GetInitProcess());

410 }

411

412 PrintMessage(L"%hs", stdout, containerId);

@@ -418,7 +432,14 @@ int ContainerService::Start(Session& session, const std::string& id, bool attach

432 THROW_IF_FAILED(session.Get()->OpenContainer(id.c_str(), &container));

433 WSLCContainerStartFlags flags = attach ? WSLCContainerStartFlagsAttach : WSLCContainerStartFlagsNone;

434 auto warningCallback = Microsoft::WRL::Make<WarningCallback>();

421 - THROW_IF_FAILED_EXCEPT(container->Start(flags, nullptr, warningCallback.Get()), WSLC_E_CONTAINER_IS_RUNNING);

435 +

436 + wsl::windows::common::ConsoleState console;

437 + WSLCProcessStartOptions startOptions{};

438 + const auto size = console.GetWindowSize();

439 + startOptions.TtyRows = size.Y;

440 + startOptions.TtyColumns = size.X;

441 +

442 + THROW_IF_FAILED_EXCEPT(container->Start(flags, &startOptions, warningCallback.Get()), WSLC_E_CONTAINER_IS_RUNNING);

443

444 if (!attach)

445 {

@@ -432,8 +453,7 @@ int ContainerService::Start(Session& session, const std::string& id, bool attach

453 THROW_IF_FAILED(process->GetFlags(&processFlags));

454 ClientRunningWSLCProcess runningProcess(std::move(process), processFlags);

455

435 - ConsoleService consoleService;

436 - return consoleService.AttachToCurrentConsole(std::move(runningProcess));

456 + return ConsoleService::AttachToCurrentConsole(console, std::move(runningProcess), true);

457 }

458

459 void ContainerService::Stop(Session& session, const std::string& id, StopContainerOptions options)

@@ -514,6 +534,14 @@ int ContainerService::Exec(Session& session, const std::string& id, ContainerOpt

534 WI_SetFlagIf(execFlags, WSLCProcessFlagsTty, options.TTY);

535

536 auto processLauncher = wsl::windows::common::WSLCProcessLauncher({}, options.Arguments, options.EnvironmentVariables, execFlags);

537 +

538 + wsl::windows::common::ConsoleState console;

539 + if (options.TTY)

540 + {

541 + const auto size = console.GetWindowSize();

542 + processLauncher.SetTtySize(size.Y, size.X);

543 + }

544 +

545 if (options.User.has_value())

546 {

547 auto user = options.User.value();

@@ -524,7 +552,7 @@ int ContainerService::Exec(Session& session, const std::string& id, ContainerOpt

552 processLauncher.SetWorkingDirectory(std::move(options.WorkingDirectory));

553 }

554

527 - return ConsoleService::AttachToCurrentConsole(processLauncher.Launch(*container));

555 + return ConsoleService::AttachToCurrentConsole(console, processLauncher.Launch(*container));

556 }

557

558 InspectContainer ContainerService::Inspect(Session& session, const std::string& id)

src/windows/wslc/services/SessionService.cpp

+2 -1

@@ -57,6 +57,7 @@ int SessionService::Attach(const std::wstring& sessionName)

58 // Configure console for interactive usage.

59 wsl::windows::common::ConsoleState console{};

60 + console.SetInteractiveMode();

61 const auto windowSize = console.GetWindowSize();

63 const std::string shell = "/bin/sh";

@@ -142,7 +143,7 @@ int SessionService::Enter(const std::wstring& storagePath, const std::wstring& d

143 const auto windowSize = console.GetWindowSize();

144 launcher.SetTtySize(windowSize.Y, windowSize.X);

145

145 - return ConsoleService::AttachToCurrentConsole(launcher.Launch(*session.get()));

146 + return ConsoleService::AttachToCurrentConsole(console, launcher.Launch(*session.get()));

147 }

148

149 std::vector<SessionInformation> SessionService::List()

src/windows/wslcsession/ServiceProcessLauncher.cpp

+3 -2

@@ -57,8 +57,9 @@ std::tuple<HRESULT, int, std::optional<ServiceRunningProcess>> ServiceProcessLau

57 int error = -1;

59 std::optional<ServiceRunningProcess> process;

60 - auto result = wil::ResultFromException(

61 - [&]() { process.emplace(virtualMachine.CreateLinuxProcess(m_executable.c_str(), options, &error), m_flags); });

60 + auto result = wil::ResultFromException([&]() {

61 + process.emplace(virtualMachine.CreateLinuxProcess(m_executable.c_str(), options, m_rows, m_columns, &error), m_flags);

62 + });

64 return {result, error, std::move(process)};

65 }

src/windows/wslcsession/WSLCContainer.cpp

+47 -11

@@ -690,7 +690,7 @@ void WSLCContainerImpl::Attach(LPCSTR DetachKeys, WSLCHandle* Stdin, WSLCHandle*

690 *Stderr = common::wslutil::ToCOMOutputHandle(reinterpret_cast<HANDLE>(stderrRead.get()), GENERIC_READ | SYNCHRONIZE, WSLCHandleTypePipe);

691 }

692

693 -void WSLCContainerImpl::Start(WSLCContainerStartFlags Flags, LPCSTR DetachKeys)

693 +void WSLCContainerImpl::Start(WSLCContainerStartFlags Flags, const WSLCProcessStartOptions* StartOptions)

694 {

695 // Acquire an exclusive lock since this method modifies m_initProcessControl, m_initProcess and m_state.

696 auto lock = m_lock.lock_exclusive();

@@ -704,6 +704,20 @@ void WSLCContainerImpl::Start(WSLCContainerStartFlags Flags, LPCSTR DetachKeys)

704 m_id.c_str(),

705 m_state);

706

707 + std::optional<std::string> detachKeys;

708 +

709 + if (StartOptions != nullptr)

710 + {

711 + detachKeys = StartOptions->DetachKeys != nullptr ? std::optional<std::string>(StartOptions->DetachKeys) : std::nullopt;

712 +

713 + THROW_HR_IF_MSG(

714 + E_INVALIDARG,

715 + WI_IsFlagSet(m_initProcessFlags, WSLCProcessFlagsTty) && (StartOptions->TtyColumns == 0 || StartOptions->TtyRows == 0),

716 + "Invalid tty size: %lu:%lu",

717 + StartOptions->TtyRows,

718 + StartOptions->TtyColumns);

719 + }

720 +

721 // Attach to the container's init process so no IO is lost.

722 std::unique_ptr<WSLCProcessIO> io;

723

@@ -711,8 +725,6 @@ void WSLCContainerImpl::Start(WSLCContainerStartFlags Flags, LPCSTR DetachKeys)

725 {

726 if (WI_IsFlagSet(Flags, WSLCContainerStartFlagsAttach))

727 {

714 - auto detachKeys = DetachKeys == nullptr ? std::nullopt : std::optional<std::string>(DetachKeys);

715 -

728 if (WI_IsFlagSet(m_initProcessFlags, WSLCProcessFlagsTty))

729 {

730 io = std::make_unique<TTYProcessIO>(TypedHandle{

@@ -753,10 +765,19 @@ void WSLCContainerImpl::Start(WSLCContainerStartFlags Flags, LPCSTR DetachKeys)

765

766 try

767 {

756 - m_dockerClient.StartContainer(m_id, DetachKeys == nullptr ? std::nullopt : std::optional<std::string>(DetachKeys));

768 + m_dockerClient.StartContainer(m_id, detachKeys);

769 }

770 CATCH_AND_THROW_DOCKER_USER_ERROR("Failed to start container '%hs'", m_id.c_str());

771

772 + if (WI_IsFlagSet(m_initProcessFlags, WSLCProcessFlagsTty) && StartOptions != nullptr)

773 + {

774 + try

775 + {

776 + m_dockerClient.ResizeContainerTty(m_id, StartOptions->TtyRows, StartOptions->TtyColumns);

777 + }

778 + CATCH_LOG();

779 + }

780 +

781 auto inspectJson = InspectLockHeld();

782 const auto pluginResult = m_pluginNotifier->OnContainerStarted(inspectJson.c_str());

783 if (FAILED(pluginResult))

@@ -1072,7 +1093,7 @@ void WSLCContainerImpl::GetInitProcess(IWSLCProcess** Process) const

1093 THROW_IF_FAILED(m_initProcess.CopyTo(__uuidof(IWSLCProcess), (void**)Process));

1094 }

1095

1075 -void WSLCContainerImpl::Exec(const WSLCProcessOptions* Options, LPCSTR DetachKeys, IWSLCProcess** Process)

1096 +void WSLCContainerImpl::Exec(const WSLCProcessOptions* Options, const WSLCProcessStartOptions* StartOptions, IWSLCProcess** Process)

1097 {

1098 THROW_HR_IF_MSG(E_INVALIDARG, Options->CommandLine.Count == 0, "Exec command line cannot be empty");

1099

@@ -1080,6 +1101,16 @@ void WSLCContainerImpl::Exec(const WSLCProcessOptions* Options, LPCSTR DetachKey

1101

1102 THROW_HR_WITH_USER_ERROR_IF(WSLC_E_CONTAINER_NOT_RUNNING, Localization::MessageWslcContainerNotRunning(m_id), m_state != WslcContainerStateRunning);

1103

1104 + if (StartOptions != nullptr)

1105 + {

1106 + THROW_HR_IF_MSG(

1107 + E_INVALIDARG,

1108 + WI_IsFlagSet(Options->Flags, WSLCProcessFlagsTty) && (StartOptions->TtyRows == 0 || StartOptions->TtyColumns == 0),

1109 + "Invalid tty size: %lu:%lu",

1110 + StartOptions->TtyRows,

1111 + StartOptions->TtyColumns);

1112 + }

1113 +

1114 common::docker_schema::CreateExec request{};

1115 request.AttachStdout = true;

1116 request.AttachStderr = true;

@@ -1100,6 +1131,11 @@ void WSLCContainerImpl::Exec(const WSLCProcessOptions* Options, LPCSTR DetachKey

1131 if (WI_IsFlagSet(Options->Flags, WSLCProcessFlagsTty))

1132 {

1133 request.Tty = true;

1134 +

1135 + if (StartOptions != nullptr)

1136 + {

1137 + request.ConsoleSize = {StartOptions->TtyRows, StartOptions->TtyColumns};

1138 + }

1139 }

1140

1141 if (WI_IsFlagSet(Options->Flags, WSLCProcessFlagsStdin))

@@ -1107,9 +1143,9 @@ void WSLCContainerImpl::Exec(const WSLCProcessOptions* Options, LPCSTR DetachKey

1143 request.AttachStdin = true;

1144 }

1145

1110 - if (DetachKeys != nullptr)

1146 + if (StartOptions != nullptr && StartOptions->DetachKeys != nullptr)

1147 {

1112 - request.DetachKeys = DetachKeys;

1148 + request.DetachKeys = StartOptions->DetachKeys;

1149 }

1150

1151 try

@@ -2120,7 +2156,7 @@ HRESULT WSLCContainer::GetInitProcess(IWSLCProcess** Process)

2156 return hr;

2157 }

2158

2123 -HRESULT WSLCContainer::Exec(const WSLCProcessOptions* Options, LPCSTR DetachKeys, IWSLCProcess** Process)

2159 +HRESULT WSLCContainer::Exec(const WSLCProcessOptions* Options, const WSLCProcessStartOptions* StartOptions, IWSLCProcess** Process)

2160 {

2161 WSLCExecutionContext context(&m_session);

2162

@@ -2129,7 +2165,7 @@ HRESULT WSLCContainer::Exec(const WSLCProcessOptions* Options, LPCSTR DetachKeys

2165 RETURN_HR_IF_MSG(E_INVALIDARG, WI_IsAnyFlagSet(Options->Flags, ~WSLCProcessFlagsValid), "Invalid flags: 0x%x", Options->Flags);

2166

2167 *Process = nullptr;

2132 - return CallImpl(&WSLCContainerImpl::Exec, Options, DetachKeys, Process);

2168 + return CallImpl(&WSLCContainerImpl::Exec, Options, StartOptions, Process);

2169 }

2170

2171 HRESULT WSLCContainer::Stop(_In_ WSLCSignal Signal, _In_ LONG TimeoutSeconds)

@@ -2146,14 +2182,14 @@ HRESULT WSLCContainer::Kill(_In_ WSLCSignal Signal)

2182 return CallImpl(&WSLCContainerImpl::Stop, Signal, {}, true);

2183 }

2184

2149 -HRESULT WSLCContainer::Start(WSLCContainerStartFlags Flags, LPCSTR DetachKeys, IWarningCallback* WarningCallback)

2185 +HRESULT WSLCContainer::Start(WSLCContainerStartFlags Flags, const WSLCProcessStartOptions* StartOptions, IWarningCallback* WarningCallback)

2186 try

2187 {

2188 WSLCExecutionContext context(&m_session, WarningCallback);

2189

2190 THROW_HR_IF_MSG(E_INVALIDARG, WI_IsAnyFlagSet(Flags, ~WSLCContainerStartFlagsValid), "Invalid flags: 0x%x", Flags);

2191

2156 - return CallImpl(&WSLCContainerImpl::Start, Flags, DetachKeys);

2192 + return CallImpl(&WSLCContainerImpl::Start, Flags, StartOptions);

2193 }

2194 CATCH_RETURN();

2195

src/windows/wslcsession/WSLCContainer.h

+4 -4

@@ -91,7 +91,7 @@ public:

92 ~WSLCContainerImpl();

94 - void Start(WSLCContainerStartFlags Flags, LPCSTR DetachKeys);

94 + void Start(WSLCContainerStartFlags Flags, const WSLCProcessStartOptions* StartOptions);

95 void Attach(LPCSTR DetachKeys, WSLCHandle* Stdin, WSLCHandle* Stdout, WSLCHandle* Stderr) const;

96 void Stop(_In_ WSLCSignal Signal, _In_ LONG TimeoutSeconds, bool Kill);

97 void Delete(WSLCDeleteFlags Flags);

@@ -100,7 +100,7 @@ public:

100 void GetCreatedAt(_Out_ ULONGLONG* CreatedAt);

101 void GetState(_Out_ WSLCContainerState* State);

102 void GetInitProcess(_Out_ IWSLCProcess** process) const;

103 - void Exec(_In_ const WSLCProcessOptions* Options, LPCSTR DetachKeys, _Out_ IWSLCProcess** Process);

103 + void Exec(_In_ const WSLCProcessOptions* Options, const WSLCProcessStartOptions* StartOptions, _Out_ IWSLCProcess** Process);

104 void Inspect(LPSTR* Output) const;

105 void Logs(WSLCLogsFlags Flags, WSLCHandle* Stdout, WSLCHandle* Stderr, ULONGLONG Since, ULONGLONG Until, ULONGLONG Tail) const;

106 void Stats(LPSTR* Output) const;

@@ -231,8 +231,8 @@ public:

231 IFACEMETHOD(Export)(_In_ WSLCHandle TarHandle) override;

232 IFACEMETHOD(GetState)(_Out_ WSLCContainerState* State) override;

233 IFACEMETHOD(GetInitProcess)(_Out_ IWSLCProcess** process) override;

234 - IFACEMETHOD(Exec)(_In_ const WSLCProcessOptions* Options, _In_opt_ LPCSTR DetachKeys, _Out_ IWSLCProcess** Process) override;

235 - IFACEMETHOD(Start)(WSLCContainerStartFlags Flags, _In_opt_ LPCSTR DetachKeys, _In_opt_ IWarningCallback* WarningCallback) override;

234 + IFACEMETHOD(Exec)(_In_ const WSLCProcessOptions* Options, _In_opt_ const WSLCProcessStartOptions* StartOptions, _Out_ IWSLCProcess** Process) override;

235 + IFACEMETHOD(Start)(WSLCContainerStartFlags Flags, _In_opt_ const WSLCProcessStartOptions* StartOptions, _In_opt_ IWarningCallback* WarningCallback) override;

236 IFACEMETHOD(Inspect)(_Out_ LPSTR* Output) override;

237 IFACEMETHOD(Logs)(_In_ WSLCLogsFlags Flags, _Out_ WSLCHandle* Stdout, _Out_ WSLCHandle* Stderr, _In_ ULONGLONG Since, _In_ ULONGLONG Until, _In_ ULONGLONG Tail) override;

238 IFACEMETHOD(GetId)(_Out_ WSLCContainerId Id) override;

src/windows/wslcsession/WSLCSession.cpp

+3 -2

@@ -2009,7 +2009,8 @@ try

2009 }

2010 CATCH_RETURN();

2011

2012 -HRESULT WSLCSession::CreateRootNamespaceProcess(LPCSTR Executable, const WSLCProcessOptions* Options, IWSLCProcess** Process, int* Errno)

2012 +HRESULT WSLCSession::CreateRootNamespaceProcess(

2013 + LPCSTR Executable, const WSLCProcessOptions* Options, ULONG TtyRows, ULONG TtyColumns, IWSLCProcess** Process, int* Errno)

2014 try

2015 {

2016 WSLCExecutionContext context(this);

@@ -2027,7 +2028,7 @@ try

2028 auto lock = m_lock.lock_shared();

2029 THROW_HR_IF(HRESULT_FROM_WIN32(ERROR_INVALID_STATE), !m_virtualMachine);

2030

2030 - auto process = m_virtualMachine->CreateLinuxProcess(Executable, *Options, Errno);

2031 + auto process = m_virtualMachine->CreateLinuxProcess(Executable, *Options, TtyRows, TtyColumns, Errno);

2032 THROW_IF_FAILED(process.CopyTo(Process));

2033

2034 return S_OK;

src/windows/wslcsession/WSLCSession.h

+6 -1

@@ -140,7 +140,12 @@ public:

140

141 // VM management.

142 IFACEMETHOD(CreateRootNamespaceProcess)(

143 - _In_ LPCSTR Executable, _In_ const WSLCProcessOptions* Options, _Out_ IWSLCProcess** VirtualMachine, _Out_ int* Errno) override;

143 + _In_ LPCSTR Executable,

144 + _In_ const WSLCProcessOptions* Options,

145 + _In_ ULONG TtyRows,

146 + _In_ ULONG TtyColumns,

147 + _Out_ IWSLCProcess** VirtualMachine,

148 + _Out_ int* Errno) override;

149

150 // Disk management.

151 IFACEMETHOD(FormatVirtualDisk)(_In_ LPCWSTR Path) override;

src/windows/wslcsession/WSLCVirtualMachine.cpp

+5 -5

@@ -386,7 +386,7 @@ void WSLCVirtualMachine::ConfigureNetworking()

386 options.CommandLine = {.Values = cmd.data(), .Count = static_cast<ULONG>(cmd.size())};

387 };

388

389 - auto process = CreateLinuxProcessImpl("/init", options, fds, nullptr, prepareCommandLine);

389 + auto process = CreateLinuxProcessImpl("/init", options, fds, 0, 0, nullptr, prepareCommandLine);

390

391 // Call back to the service to configure the networking engine.

392 auto gnsHandle = process->GetStdHandle(gnsChannelFd);

@@ -639,7 +639,7 @@ std::string WSLCVirtualMachine::GetVhdDevicePath(ULONG Lun)

639 }

640

641 Microsoft::WRL::ComPtr<WSLCProcess> WSLCVirtualMachine::CreateLinuxProcess(

642 - _In_ LPCSTR Executable, _In_ const WSLCProcessOptions& Options, int* Errno, const TPrepareCommandLine& PrepareCommandLine)

642 + _In_ LPCSTR Executable, _In_ const WSLCProcessOptions& Options, ULONG TtyRows, ULONG TtyColumns, int* Errno, const TPrepareCommandLine& PrepareCommandLine)

643 {

644 // Check if this is a tty or not

645 std::vector<WSLCProcessFd> fds;

@@ -659,11 +659,11 @@ Microsoft::WRL::ComPtr<WSLCProcess> WSLCVirtualMachine::CreateLinuxProcess(

659 fds.emplace_back(WSLCProcessFd{.Fd = WSLCFDStderr, .Type = WSLCFdType::WSLCFdTypeDefault});

660 }

661

662 - return CreateLinuxProcessImpl(Executable, Options, fds, Errno, PrepareCommandLine);

662 + return CreateLinuxProcessImpl(Executable, Options, fds, TtyRows, TtyColumns, Errno, PrepareCommandLine);

663 }

664

665 Microsoft::WRL::ComPtr<WSLCProcess> WSLCVirtualMachine::CreateLinuxProcessImpl(

666 - LPCSTR Executable, const WSLCProcessOptions& Options, const std::vector<WSLCProcessFd>& Fds, int* Errno, const TPrepareCommandLine& PrepareCommandLine)

666 + LPCSTR Executable, const WSLCProcessOptions& Options, const std::vector<WSLCProcessFd>& Fds, ULONG TtyRows, ULONG TtyColumns, int* Errno, const TPrepareCommandLine& PrepareCommandLine)

667 {

668 // N.B This check is there to prevent processes from being started before the VM is done initializing.

669 // to avoid potential deadlocks, since the processExitThread is required to signal the process exit events.

@@ -729,7 +729,7 @@ Microsoft::WRL::ComPtr<WSLCProcess> WSLCVirtualMachine::CreateLinuxProcessImpl(

729 // If this is an interactive tty, we need a relay process

730 if (tty != nullptr)

731 {

732 - auto [grandChildPid, ptyMaster, grandChildChannel] = Fork(childChannel, WSLC_FORK::Pty, Options.TtyRows, Options.TtyColumns);

732 + auto [grandChildPid, ptyMaster, grandChildChannel] = Fork(childChannel, WSLC_FORK::Pty, TtyRows, TtyColumns);

733 WSLC_TTY_RELAY relayMessage{};

734 relayMessage.TtyMaster = ptyMaster;

735 relayMessage.Socket = tty->Fd;

src/windows/wslcsession/WSLCVirtualMachine.h

@@ -144,6 +144,8 @@ public:

144 Microsoft::WRL::ComPtr<WSLCProcess> CreateLinuxProcess(

145 _In_ LPCSTR Executable,

146 _In_ const WSLCProcessOptions& Options,

147 + _In_ ULONG TtyRows = 0,

148 + _In_ ULONG TtyColumns = 0,

149 int* Errno = nullptr,

150 const TPrepareCommandLine& PrepareCommandLine = [](const auto&) {});

151

@@ -187,6 +189,8 @@ private:

189 _In_ LPCSTR Executable,

190 _In_ const WSLCProcessOptions& Options,

191 _In_ const std::vector<WSLCProcessFd>& Fds = {},

192 + _In_ ULONG TtyRows = 0,

193 + _In_ ULONG TtyColumns = 0,

194 int* Errno = nullptr,

195 const TPrepareCommandLine& PrepareCommandLine = [](const auto&) {});

196

test/windows/WSLCTests.cpp

+70 -2

@@ -5522,6 +5522,15 @@ class WSLCTests

5522 VERIFY_SUCCEEDED(m_defaultSession->CreateContainer(&options, nullptr, &container));

5523 VERIFY_SUCCEEDED(container->Delete(WSLCDeleteFlagsNone));

5524 }

5525 +

5526 + // Validate that invalid tty sizes are rejected.

5527 + {

5528 + WSLCContainerLauncher launcher("debian:latest", "invalid-tty-size-init", {"/bin/sh"}, {}, {}, WSLCProcessFlagsTty | WSLCProcessFlagsStdin);

5529 + launcher.SetTtySize(0, 0);

5530 +

5531 + auto [result, container] = launcher.LaunchNoThrow(*m_defaultSession);

5532 + VERIFY_ARE_EQUAL(result, E_INVALIDARG);

5533 + }

5534 }

5535

5536 WSLC_TEST_METHOD(ContainerStartAfterStop)

@@ -7182,6 +7191,18 @@ class WSLCTests

7191 VERIFY_ARE_EQUAL(result, WSLC_E_CONTAINER_NOT_RUNNING);

7192 ValidateCOMErrorMessage(std::format(L"Container '{}' is not running.", id));

7193 }

7194 +

7195 + // Validate that invalid tty sizes are rejected.

7196 + {

7197 + WSLCContainerLauncher launcher("debian:latest", "invalid-tty-size-exec", {"/bin/cat"}, {}, {}, WSLCProcessFlagsStdin);

7198 + auto container = launcher.Launch(*m_defaultSession);

7199 +

7200 + WSLCProcessLauncher execLauncher({}, {"/bin/sh", "-c", "stty size"}, {}, WSLCProcessFlagsTty | WSLCProcessFlagsStdin);

7201 + execLauncher.SetTtySize(0, 0);

7202 +

7203 + auto [result, process] = execLauncher.LaunchNoThrow(container.Get());

7204 + VERIFY_ARE_EQUAL(result, E_INVALIDARG);

7205 + }

7206 }

7207

7208 WSLC_TEST_METHOD(ExecContainerDelete)

@@ -8981,6 +9002,44 @@ class WSLCTests

9002 }

9003 }

9004

9005 + WSLC_TEST_METHOD(TtySize)

9006 + {

9007 + constexpr ULONG c_rows = 43;

9008 + constexpr ULONG c_columns = 42;

9009 + const std::string expectedSize = "43 42";

9010 +

9011 + // Container init process.

9012 + {

9013 + WSLCContainerLauncher launcher(

9014 + "debian:latest", "tty-size-init", {"/bin/sh", "-c", "while true; do stty size; sleep 1; done"}, {}, {}, WSLCProcessFlagsTty | WSLCProcessFlagsStdin);

9015 + launcher.SetTtySize(c_rows, c_columns);

9016 +

9017 + auto container = launcher.Launch(*m_defaultSession);

9018 + auto process = container.GetInitProcess();

9019 + auto tty = process.GetStdHandle(WSLCFDTty);

9020 +

9021 + // Wait for the size to be reflected in a loop, since the tty size is applied asynchronously.

9022 + PartialHandleRead reader(tty.get());

9023 + wsl::shared::retry::RetryWithTimeout<void>(

9024 + [&]() { THROW_HR_IF(E_ABORT, reader.GetData().find(expectedSize) == std::string::npos); },

9025 + std::chrono::milliseconds(100),

9026 + std::chrono::seconds(60));

9027 + }

9028 +

9029 + // Exec process.

9030 + {

9031 + WSLCContainerLauncher launcher("debian:latest", "tty-size-exec", {"/bin/cat"}, {}, {}, WSLCProcessFlagsStdin);

9032 + auto container = launcher.Launch(*m_defaultSession);

9033 +

9034 + WSLCProcessLauncher execLauncher({}, {"/usr/bin/stty", "size"}, {}, WSLCProcessFlagsTty | WSLCProcessFlagsStdin);

9035 + execLauncher.SetTtySize(c_rows, c_columns);

9036 +

9037 + auto process = execLauncher.Launch(container.Get());

9038 +

9039 + ValidateProcessOutput(process, {{WSLCFDTty, expectedSize + "\r\n"}});

9040 + }

9041 + }

9042 +

9043 WSLC_TEST_METHOD(ContainerStats_RunningContainer)

9044 {

9045 // Start a long-lived detached container on a bridged network so network stats are populated.

@@ -9574,7 +9633,12 @@ class WSLCTests

9633 WSLCContainerLauncher launcher("debian:latest", "test-detach", {"sleep", "9999999"}, {}, {}, WSLCProcessFlagsStdin | WSLCProcessFlagsTty);

9634

9635 auto container = launcher.Create(*m_defaultSession);

9577 - VERIFY_SUCCEEDED(container.Get().Start(WSLCContainerStartFlagsAttach, DetachKeys, nullptr));

9636 +

9637 + WSLCProcessStartOptions startOptions{};

9638 + startOptions.TtyRows = 24;

9639 + startOptions.TtyColumns = 80;

9640 + startOptions.DetachKeys = DetachKeys;

9641 + VERIFY_SUCCEEDED(container.Get().Start(WSLCContainerStartFlagsAttach, &startOptions, nullptr));

9642

9643 auto initProcess = container.GetInitProcess();

9644

@@ -9625,7 +9689,11 @@ class WSLCTests

9689 WSLCContainerLauncher launcher("debian:latest", "test-detach", {"cat"}, {}, {}, WSLCProcessFlagsStdin | WSLCProcessFlagsTty);

9690 auto container = launcher.Create(*m_defaultSession);

9691

9628 - VERIFY_ARE_EQUAL(container.Get().Start(WSLCContainerStartFlagsAttach, "invalid", nullptr), E_INVALIDARG);

9692 + WSLCProcessStartOptions invalidDetachOptions{};

9693 + invalidDetachOptions.TtyRows = 24;

9694 + invalidDetachOptions.TtyColumns = 80;

9695 + invalidDetachOptions.DetachKeys = "invalid";

9696 + VERIFY_ARE_EQUAL(container.Get().Start(WSLCContainerStartFlagsAttach, &invalidDetachOptions, nullptr), E_INVALIDARG);

9697

9698 VERIFY_SUCCEEDED(container.Get().Start(WSLCContainerStartFlagsNone, nullptr, nullptr));

9699

test/windows/wslc/e2e/WSLCE2EContainerAttachTests.cpp

+3 -5

@@ -57,15 +57,13 @@ class WSLCE2EContainerAttachTests

57 result.Verify({.Stderr = L"", .ExitCode = 0});

58 auto containerId = result.GetStdoutOneLine();

60 - const auto& expectedAttachPrompt = VT::BuildContainerAttachPrompt(prompt);

60 const auto& expectedPrompt = VT::BuildContainerPrompt(prompt);

62 auto session = RunWslcInteractive(std::format(L"container attach {}", containerId));

63 VERIFY_IS_TRUE(session.IsRunning(), L"Container session should be running");

66 - // The container attach prompt appears twice.

67 - session.ExpectStdout(expectedAttachPrompt);

68 - session.ExpectStdout(expectedAttachPrompt);

65 + // Ignore resize-repaint messages. Those are emitted when the the tty initial size is set, which can happen before or after we start running commands.

66 + session.IgnoreSequence(VT::BuildContainerAttachPrompt(prompt));

68 session.WriteLine("echo hello");

69 session.ExpectCommandEcho("echo hello");

@@ -164,4 +162,4 @@ private:

162 return options.str();

163 }

164 };

167 -} // namespace WSLCE2ETests

\ No newline at end of file

165 +} // namespace WSLCE2ETests

test/windows/wslc/e2e/WSLCE2EContainerCreateTests.cpp

+4 -1

@@ -469,11 +469,14 @@ class WSLCE2EContainerCreateTests

469 result.Verify({.Stderr = L"", .ExitCode = 0});

470 auto containerId = result.GetStdoutOneLine();

471

472 - const auto& expectedPrompt = VT::BuildContainerPrompt(prompt);

472 + const auto& expectedPrompt = VT::BuildContainerPrompt(prompt, true);

473

474 auto session = RunWslcInteractive(std::format(L"container start --attach {}", containerId));

475 VERIFY_IS_TRUE(session.IsRunning(), L"Container session should be running");

476

477 + // Ignore resize-repaint messages. Those are emitted when the the tty initial size is set, which can happen before or after we start running commands.

478 + session.IgnoreSequence(VT::BuildContainerAttachPrompt(prompt));

479 +

480 session.ExpectStdout(expectedPrompt);

481

482 session.WriteLine("echo hello");

test/windows/wslc/e2e/WSLCE2EContainerExecTests.cpp

+16

@@ -154,6 +154,22 @@ class WSLCE2EContainerExecTests

154 session.VerifyNoErrors();

155 }

156

157 + WSLC_TEST_METHOD(WSLCE2E_Container_Exec_PseudoConsole_TerminalSize)

158 + {

159 + VerifyContainerIsNotListed(WslcContainerName);

160 +

161 + auto result = RunWslc(std::format(L"container run -d --name {} {} sleep infinity", WslcContainerName, DebianImage.NameAndTag()));

162 + result.Verify({.Stderr = L"", .ExitCode = 0});

163 +

164 + constexpr SHORT columns = 42;

165 + constexpr SHORT rows = 43;

166 + const auto commandLine =

167 + std::format(L"container exec -it {} /bin/sh -c -- \"while true; do stty size; sleep 1; done\"", WslcContainerName);

168 +

169 + auto session = RunWslcInteractive(commandLine, ElevationType::Elevated, PseudoConsole{columns, rows});

170 + VerifyPseudoConsoleTtySize(session, columns, rows);

171 + }

172 +

173 WSLC_TEST_METHOD(WSLCE2E_Container_Exec_EnvOption)

174 {

175 auto result = RunWslc(std::format(L"container run -d --name {} {} sleep infinity", WslcContainerName, DebianImage.NameAndTag()));

test/windows/wslc/e2e/WSLCE2EContainerRunTests.cpp

+19 -1

@@ -529,7 +529,10 @@ class WSLCE2EContainerRunTests

529 std::format(L"container run -it -e PS1={} --name {} {} bash --norc", prompt, WslcContainerName, DebianImage.NameAndTag()));

530 VERIFY_IS_TRUE(session.IsRunning(), L"Container session should be running");

531

532 - const auto& expectedPrompt = VT::BuildContainerPrompt(prompt);

532 + // Ignore resize-repaint messages. Those are emitted when the the tty initial size is set, which can happen before or after we start running commands.

533 + session.IgnoreSequence(VT::BuildContainerAttachPrompt(prompt));

534 +

535 + const auto& expectedPrompt = VT::BuildContainerPrompt(prompt, true);

536 session.ExpectStdout(expectedPrompt);

537

538 session.WriteLine("echo hello");

@@ -567,6 +570,21 @@ class WSLCE2EContainerRunTests

570 session.VerifyNoErrors();

571 }

572

573 + WSLC_TEST_METHOD(WSLCE2E_Container_Run_PseudoConsole_TerminalSize)

574 + {

575 + VerifyContainerIsNotListed(WslcContainerName);

576 +

577 + constexpr SHORT columns = 42;

578 + constexpr SHORT rows = 43;

579 + const auto commandLine = std::format(

580 + L"container run --rm -it --name {} {} /bin/sh -c \"while true; do stty size; sleep 1; done\"",

581 + WslcContainerName,

582 + DebianImage.NameAndTag());

583 +

584 + auto session = RunWslcInteractive(commandLine, ElevationType::Elevated, PseudoConsole{columns, rows});

585 + VerifyPseudoConsoleTtySize(session, columns, rows);

586 + }

587 +

588 WSLC_TEST_METHOD(WSLCE2E_Container_Run_Tmpfs)

589 {

590 auto result = RunWslc(std::format(

test/windows/wslc/e2e/WSLCE2EHelpers.cpp

+40

@@ -553,4 +553,44 @@ std::wstring GetPythonHttpServerScript(uint16_t port)

553 {

554 return std::format(L"python3 -m http.server {}", port);

555 }

556 +

557 +namespace {

558 +

559 + void WaitForTtySize(const WSLCInteractiveSession& session, SHORT columns, SHORT rows)

560 + {

561 + try

562 + {

563 + wsl::shared::retry::RetryWithTimeout<void>(

564 + [&]() {

565 + const std::string data = session.GetStdoutData();

566 + THROW_HR_IF(E_ABORT, data.find(std::format("{} {}\r\n", rows, columns)) == std::string::npos);

567 + },

568 + std::chrono::milliseconds(200),

569 + std::chrono::seconds(60));

570 + }

571 + catch (...)

572 + {

573 + const std::string data = session.GetStdoutData();

574 + VERIFY_FAIL(std::format(

575 + L"Timed out waiting for tty resize. Captured pseudoconsole output: \"{}\"",

576 + wsl::shared::string::MultiByteToWide(EscapeString(data)))

577 + .c_str());

578 + }

579 + }

580 +

581 +} // namespace

582 +

583 +void VerifyPseudoConsoleTtySize(WSLCInteractiveSession& session, SHORT columns, SHORT rows)

584 +{

585 + constexpr SHORT resizedColumns = 100;

586 + constexpr SHORT resizedRows = 37;

587 + VERIFY_IS_TRUE(columns != resizedColumns || rows != resizedRows, L"Resized tty size must differ from the initial size");

588 +

589 + WaitForTtySize(session, columns, rows);

590 +

591 + session.ResizePseudoConsole(resizedColumns, resizedRows);

592 + WaitForTtySize(session, resizedColumns, resizedRows);

593 +

594 + session.Terminate();

595 +}

596 } // namespace WSLCE2ETests

test/windows/wslc/e2e/WSLCE2EHelpers.h

@@ -192,6 +192,8 @@ inline void VerifyContainerIsNotListed(const std::wstring& containerNameOrId)

192

193 wil::com_ptr<IWSLCSession> OpenDefaultElevatedSession();

194

195 +void VerifyPseudoConsoleTtySize(WSLCInteractiveSession& session, SHORT columns, SHORT rows);

196 +

197 // Starts a local registry container with host networking using the COM API.

198 // Returns the running container (holds it alive) and the registry address (e.g. "127.0.0.1:PORT").

199 std::pair<wsl::windows::common::RunningWSLCContainer, std::string> StartLocalRegistry(

test/windows/wslc/e2e/WSLCExecutor.cpp

+85 -13

@@ -235,20 +235,40 @@ std::wstring GetWslcHeader()

235 return header.str();

236 }

237

238 -WSLCInteractiveSession RunWslcInteractive(const std::wstring& commandLine, ElevationType elevationType)

238 +WSLCInteractiveSession RunWslcInteractive(const std::wstring& commandLine, ElevationType elevationType, std::optional<PseudoConsole> pseudoConsole)

239 {

240 auto cmd = L"\"" + GetWslcPath() + L"\" " + commandLine;

241

242 - auto [childStdinRead, parentStdinWrite] = wsl::windows::common::wslutil::OpenAnonymousPipe(65536, false, true);

243 - auto [parentStdoutRead, childStdoutWrite] = wsl::windows::common::wslutil::OpenAnonymousPipe(65536, true, false);

244 - auto [parentStderrRead, childStderrWrite] = wsl::windows::common::wslutil::OpenAnonymousPipe(65536, true, false);

242 + wsl::windows::common::SubProcess process(nullptr, cmd.c_str());

243

246 - THROW_IF_WIN32_BOOL_FALSE(SetHandleInformation(childStdinRead.get(), HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT));

247 - THROW_IF_WIN32_BOOL_FALSE(SetHandleInformation(childStdoutWrite.get(), HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT));

248 - THROW_IF_WIN32_BOOL_FALSE(SetHandleInformation(childStderrWrite.get(), HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT));

244 + wil::unique_hfile parentStdinWrite;

245 + wil::unique_hfile parentStdoutRead;

246 + wil::unique_hfile parentStderrRead;

247 + wsl::windows::common::helpers::unique_pseudo_console console;

248

250 - wsl::windows::common::SubProcess process(nullptr, cmd.c_str());

251 - process.SetStdHandles(childStdinRead.get(), childStdoutWrite.get(), childStderrWrite.get());

249 + wil::unique_hfile childStdinRead;

250 + wil::unique_hfile childStdoutWrite;

251 + wil::unique_hfile childStderrWrite;

252 +

253 + if (pseudoConsole.has_value())

254 + {

255 + process.SetPseudoConsole(pseudoConsole->Handle.get());

256 + parentStdinWrite = std::move(pseudoConsole->InputWrite);

257 + parentStdoutRead = std::move(pseudoConsole->OutputRead);

258 + console = std::move(pseudoConsole->Handle);

259 + }

260 + else

261 + {

262 + std::tie(childStdinRead, parentStdinWrite) = wsl::windows::common::wslutil::OpenAnonymousPipe(65536, false, true);

263 + std::tie(parentStdoutRead, childStdoutWrite) = wsl::windows::common::wslutil::OpenAnonymousPipe(65536, true, false);

264 + std::tie(parentStderrRead, childStderrWrite) = wsl::windows::common::wslutil::OpenAnonymousPipe(65536, true, false);

265 +

266 + THROW_IF_WIN32_BOOL_FALSE(SetHandleInformation(childStdinRead.get(), HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT));

267 + THROW_IF_WIN32_BOOL_FALSE(SetHandleInformation(childStdoutWrite.get(), HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT));

268 + THROW_IF_WIN32_BOOL_FALSE(SetHandleInformation(childStderrWrite.get(), HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT));

269 +

270 + process.SetStdHandles(childStdinRead.get(), childStdoutWrite.get(), childStderrWrite.get());

271 + }

272

273 wil::unique_handle nonElevatedToken;

274 if (elevationType == ElevationType::NonElevated)

@@ -269,7 +289,22 @@ WSLCInteractiveSession RunWslcInteractive(const std::wstring& commandLine, Eleva

289 std::move(parentStdoutRead),

290 std::move(parentStderrRead),

291 std::move(processHandle),

272 - std::move(nonElevatedToken)); // Transfer token ownership to the session

292 + std::move(nonElevatedToken), // Transfer token ownership to the session

293 + std::move(console));

294 +}

295 +

296 +PseudoConsole::PseudoConsole(SHORT columns, SHORT rows)

297 +{

298 + auto [inputRead, inputWrite] = wsl::windows::common::wslutil::OpenAnonymousPipe(0, false, true);

299 +

300 + auto [outputRead, outputWrite] = wsl::windows::common::wslutil::OpenAnonymousPipe(0, true, false);

301 +

302 + HPCON rawPseudoConsole{};

303 + THROW_IF_FAILED(::CreatePseudoConsole(COORD{columns, rows}, inputRead.get(), outputWrite.get(), 0, &rawPseudoConsole));

304 + Handle.reset(rawPseudoConsole);

305 +

306 + InputWrite = std::move(inputWrite);

307 + OutputRead = std::move(outputRead);

308 }

309

310 // WSLCInteractiveSession implementation

@@ -280,16 +315,24 @@ WSLCInteractiveSession::WSLCInteractiveSession(

315 wil::unique_hfile stdoutRead,

316 wil::unique_hfile stderrRead,

317 wil::unique_handle processHandle,

283 - wil::unique_handle nonElevatedToken) :

318 + wil::unique_handle nonElevatedToken,

319 + wsl::windows::common::helpers::unique_pseudo_console pseudoConsole) :

320 CommandLine(std::move(commandLine)),

321 m_stdinWrite(std::move(stdinWrite)),

322 m_stdoutRead(std::move(stdoutRead)),

323 m_stderrRead(std::move(stderrRead)),

324 + m_pseudoConsole(std::move(pseudoConsole)),

325 m_processHandle(std::move(processHandle)),

326 m_nonElevatedToken(std::move(nonElevatedToken))

327 {

328 m_stdoutReader = std::make_unique<PartialHandleRead>(m_stdoutRead.get());

292 - m_stderrReader = std::make_unique<PartialHandleRead>(m_stderrRead.get());

329 +

330 + // In pseudoconsole mode stderr is multiplexed onto the conpty output, so there is no

331 + // separate stderr handle to read from.

332 + if (m_stderrRead.is_valid())

333 + {

334 + m_stderrReader = std::make_unique<PartialHandleRead>(m_stderrRead.get());

335 + }

336 }

337

338 WSLCInteractiveSession::~WSLCInteractiveSession()

@@ -313,12 +356,34 @@ WSLCInteractiveSession::~WSLCInteractiveSession()

356

357 void WSLCInteractiveSession::ExpectStdout(const std::string& expected)

358 {

359 + if (m_ignoreSequence.has_value())

360 + {

361 + while (m_stdoutReader->ReadBytes(m_ignoreSequence->size()) == *m_ignoreSequence)

362 + {

363 + Log::Comment(std::format(L"Consuming ignored sequence: \"{}\"", wsl::shared::string::MultiByteToWide(EscapeString(*m_ignoreSequence)))

364 + .c_str());

365 + m_stdoutReader->ConsumeBytes(m_ignoreSequence->size());

366 + }

367 + }

368 +

369 Log::Comment(std::format(L"Expecting stdout: \"{}\"", wsl::shared::string::MultiByteToWide(EscapeString(expected))).c_str());

370 m_stdoutReader->ExpectConsume(expected);

371 }

372

373 +std::string WSLCInteractiveSession::GetStdoutData() const

374 +{

375 + return m_stdoutReader->GetData();

376 +}

377 +

378 +void WSLCInteractiveSession::ResizePseudoConsole(SHORT columns, SHORT rows)

379 +{

380 + VERIFY_IS_TRUE(static_cast<bool>(m_pseudoConsole), L"ResizePseudoConsole requires a pseudoconsole-backed session");

381 + THROW_IF_FAILED(::ResizePseudoConsole(m_pseudoConsole.get(), COORD{columns, rows}));

382 +}

383 +

384 void WSLCInteractiveSession::ExpectStderr(const std::string& expected)

385 {

386 + WI_ASSERT(m_stderrReader.get() != nullptr);

387 Log::Comment(std::format(L"Expecting stderr: \"{}\"", wsl::shared::string::MultiByteToWide(EscapeString(expected))).c_str());

388 m_stderrReader->ExpectConsume(expected);

389 }

@@ -329,6 +394,12 @@ void WSLCInteractiveSession::ExpectCommandEcho(const std::string& command)

394 ExpectStdout(std::format("{}\r\n{}\r", command, VT::B_END));

395 }

396

397 +void WSLCInteractiveSession::IgnoreSequence(const std::string& sequence)

398 +{

399 + VERIFY_IS_FALSE(m_ignoreSequence.has_value());

400 + m_ignoreSequence = sequence;

401 +}

402 +

403 void WSLCInteractiveSession::Write(const std::string& data)

404 {

405 Log::Comment(std::format(L"Writing to stdin: \"{}\"", wsl::shared::string::MultiByteToWide(EscapeString(data))).c_str());

@@ -434,6 +505,7 @@ bool WSLCInteractiveSession::Terminate(UINT exitCode)

505

506 void WSLCInteractiveSession::VerifyNoErrors()

507 {

508 + WI_ASSERT(m_stderrReader.get() != nullptr);

509 m_stderrReader->ExpectClosed(DefaultWaitTimeoutMs);

510

511 // Verify that stderr was actually empty - not just closed

@@ -459,4 +531,4 @@ int WSLCInteractiveSession::ExitAndVerifyNoErrors(DWORD timeoutMs)

531 return exitCode;

532 }

533

462 -} // namespace WSLCE2ETests

\ No newline at end of file

534 +} // namespace WSLCE2ETests

test/windows/wslc/e2e/WSLCExecutor.h

+24 -2

@@ -47,6 +47,18 @@ struct WSLCExecutionResult

47 bool StdoutContainsSubstring(const std::wstring& substring) const;

48 };

50 +struct PseudoConsole

51 +{

52 + NON_COPYABLE(PseudoConsole);

53 + DEFAULT_MOVABLE(PseudoConsole);

54 +

55 + PseudoConsole(SHORT columns, SHORT rows);

56 +

57 + wil::unique_hfile InputWrite;

58 + wil::unique_hfile OutputRead;

59 + wsl::windows::common::helpers::unique_pseudo_console Handle;

60 +};

61 +

62 // Interactive session for testing wslc commands that require stdin/stdout interaction.

63 // Uses PartialHandleRead for race-free output validation

64 struct WSLCInteractiveSession

@@ -57,7 +69,8 @@ struct WSLCInteractiveSession

69 wil::unique_hfile stdoutRead,

70 wil::unique_hfile stderrRead,

71 wil::unique_handle processHandle,

60 - wil::unique_handle nonElevatedToken = wil::unique_handle{});

72 + wil::unique_handle nonElevatedToken = wil::unique_handle{},

73 + wsl::windows::common::helpers::unique_pseudo_console pseudoConsole = {});

74 ~WSLCInteractiveSession();

76 // Non-copyable, non-movable

@@ -74,6 +87,12 @@ struct WSLCInteractiveSession

87 void ExpectStderr(const std::string& expected);

88 void ExpectCommandEcho(const std::string& command);

90 + void IgnoreSequence(const std::string& sequence);

91 +

92 + std::string GetStdoutData() const;

93 +

94 + void ResizePseudoConsole(SHORT columns, SHORT rows);

95 +

96 bool IsRunning() const;

97 void CloseStdin();

98 std::optional<int> GetExitCode() const;

@@ -88,10 +107,12 @@ private:

107 wil::unique_hfile m_stdinWrite;

108 wil::unique_hfile m_stdoutRead;

109 wil::unique_hfile m_stderrRead;

110 + wsl::windows::common::helpers::unique_pseudo_console m_pseudoConsole;

111 wil::unique_handle m_processHandle;

112 wil::unique_handle m_nonElevatedToken; // Keep token alive for the lifetime of the session

113 std::unique_ptr<PartialHandleRead> m_stdoutReader;

114 std::unique_ptr<PartialHandleRead> m_stderrReader;

115 + std::optional<std::string> m_ignoreSequence;

116 };

117

118 WSLCExecutionResult RunWslc(const std::wstring& commandLine, ElevationType elevationType = ElevationType::Elevated);

@@ -102,6 +123,7 @@ WSLCExecutionResult RunWslcAndRedirectToFile(

123 void RunWslcAndVerify(const std::wstring& cmd, const WSLCExecutionResult& expected, ElevationType elevationType = ElevationType::Elevated);

124

125 std::wstring GetWslcHeader();

105 -WSLCInteractiveSession RunWslcInteractive(const std::wstring& commandLine, ElevationType elevationType = ElevationType::Elevated);

126 +WSLCInteractiveSession RunWslcInteractive(

127 + const std::wstring& commandLine, ElevationType elevationType = ElevationType::Elevated, std::optional<PseudoConsole> pseudoConsole = std::nullopt);

128

129 } // namespace WSLCE2ETests