ps_status.c Source File (original) (raw)

18#if defined(__darwin__)

19#include <crt_externs.h>

20#endif

26#if !defined(WIN32) || defined(_MSC_VER)

28#endif

51#if defined(HAVE_SETPROCTITLE_FAST)

52#define PS_USE_SETPROCTITLE_FAST

53#elif defined(HAVE_SETPROCTITLE)

54#define PS_USE_SETPROCTITLE

55#elif defined(__linux__) || defined(__sun) || defined(__darwin__)

56#define PS_USE_CLOBBER_ARGV

57#elif defined(WIN32)

58#define PS_USE_WIN32

59#else

60#define PS_USE_NONE

61#endif

65#if defined(__linux__) || defined(__darwin__)

66#define PS_PADDING '\0'

67#else

68#define PS_PADDING ' '

69#endif

72#ifndef PS_USE_NONE

74#ifndef PS_USE_CLOBBER_ARGV

76#define PS_BUFFER_SIZE 256

77static char ps_buffer[PS_BUFFER_SIZE];

78static const size_t ps_buffer_size = PS_BUFFER_SIZE;

79#else

80static char *ps_buffer;

81static size_t ps_buffer_size;

82static size_t last_status_len;

83#endif

85static size_t ps_buffer_cur_len;

87static size_t ps_buffer_fixed_size;

93static size_t ps_buffer_nosuffix_len;

95static void flush_ps_display(void);

97#endif

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118char **

120{

123

124#if defined(PS_USE_CLOBBER_ARGV)

125

126

127

128

129

130 {

131 char *end_of_area = NULL;

132 char **new_environ;

133 int i;

134

135

136

137

138 for (i = 0; i < argc; i++)

139 {

140 if (i == 0 || end_of_area + 1 == argv[i])

141 end_of_area = argv[i] + strlen(argv[i]);

142 }

143

144 if (end_of_area == NULL)

145 {

146 ps_buffer = NULL;

147 ps_buffer_size = 0;

148 return argv;

149 }

150

151

152

153

155 {

156 if (end_of_area + 1 == environ[i])

157 {

158

159

160

161

162

163

164

165

166

167#if defined(__linux__) && (!defined(__GLIBC__) && !defined(__UCLIBC__))

168 if (strncmp(environ[i], "LD_LIBRARY_PATH=", 16) == 0)

169 {

170

171

172

173

174

175

176 end_of_area = environ[i] + 15;

177 }

178 else

179#endif

180 {

182 }

183 }

184 }

185

186 ps_buffer = argv[0];

187 last_status_len = ps_buffer_size = end_of_area - argv[0];

188

189

190

191

192 new_environ = (char **) malloc((i + 1) * sizeof(char *));

193 if (!new_environ)

194 {

196 exit(1);

197 }

199 {

200 new_environ[i] = strdup(environ[i]);

201 if (!new_environ[i])

202 {

204 exit(1);

205 }

206 }

207 new_environ[i] = NULL;

209 }

210

211

212

213

214

215

216

217

218

219

220

221

222

223 {

224 char **new_argv;

225 int i;

226

227 new_argv = (char **) malloc((argc + 1) * sizeof(char *));

228 if (!new_argv)

229 {

231 exit(1);

232 }

233 for (i = 0; i < argc; i++)

234 {

235 new_argv[i] = strdup(argv[i]);

236 if (!new_argv[i])

237 {

239 exit(1);

240 }

241 }

242 new_argv[argc] = NULL;

243

244#if defined(__darwin__)

245

246

247

248

249

250 *_NSGetArgv() = new_argv;

251#endif

252

253 argv = new_argv;

254 }

255#endif

256

257 return argv;

258}

259

260

261

262

263

264

265

266

267

268void

270{

271#ifndef PS_USE_NONE

272 bool save_update_process_title;

273#endif

274

276 if (!fixed_part)

278

279#ifndef PS_USE_NONE

280

282 return;

283

284

286 return;

287

288#ifdef PS_USE_CLOBBER_ARGV

289

290 if (!ps_buffer)

291 return;

292

293

295 save_argv[i] = ps_buffer + ps_buffer_size;

296#endif

297

298

299

300

301

302#if defined(PS_USE_SETPROCTITLE) || defined(PS_USE_SETPROCTITLE_FAST)

303

304

305

306

307

308#define PROGRAM_NAME_PREFIX ""

309#else

310#define PROGRAM_NAME_PREFIX "postgres: "

311#endif

312

314 {

315 snprintf(ps_buffer, ps_buffer_size,

316 PROGRAM_NAME_PREFIX "%s ",

317 fixed_part);

318 }

319 else

320 {

321 snprintf(ps_buffer, ps_buffer_size,

322 PROGRAM_NAME_PREFIX "%s: %s ",

324 }

325

326 ps_buffer_cur_len = ps_buffer_fixed_size = strlen(ps_buffer);

327

328

329

330

335#endif

336}

337

338#ifndef PS_USE_NONE

339

340

341

342

343

344static bool

345update_ps_display_precheck(void)

346{

347

349 return false;

350

351

353 return false;

354

355#ifdef PS_USE_CLOBBER_ARGV

356

357 if (!ps_buffer)

358 return false;

359#endif

360

361 return true;

362}

363#endif

364

365

366

367

368

369

370void

372{

373#ifndef PS_USE_NONE

374 size_t len;

375

376

377 if (!update_ps_display_precheck())

378 return;

379

380

381 if (ps_buffer_nosuffix_len > 0)

382 ps_buffer_cur_len = ps_buffer_nosuffix_len;

383 else

384 ps_buffer_nosuffix_len = ps_buffer_cur_len;

385

386 len = strlen(suffix);

387

388

389 if (ps_buffer_cur_len + len + 1 >= ps_buffer_size)

390 {

391

392 if (ps_buffer_cur_len < ps_buffer_size - 1)

393 {

394

395 ps_buffer[ps_buffer_cur_len++] = ' ';

396

397

398 memcpy(ps_buffer + ps_buffer_cur_len, suffix,

399 ps_buffer_size - ps_buffer_cur_len - 1);

400 ps_buffer[ps_buffer_size - 1] = '\0';

401 ps_buffer_cur_len = ps_buffer_size - 1;

402 }

403 }

404 else

405 {

406 ps_buffer[ps_buffer_cur_len++] = ' ';

407 memcpy(ps_buffer + ps_buffer_cur_len, suffix, len + 1);

408 ps_buffer_cur_len = ps_buffer_cur_len + len;

409 }

410

411 Assert(strlen(ps_buffer) == ps_buffer_cur_len);

412

413

414 flush_ps_display();

415#endif

416}

417

418

419

420

421

422void

424{

425#ifndef PS_USE_NONE

426

427 if (!update_ps_display_precheck())

428 return;

429

430

431 if (ps_buffer_nosuffix_len == 0)

432 return;

433

434

435 ps_buffer[ps_buffer_nosuffix_len] = '\0';

436 ps_buffer_cur_len = ps_buffer_nosuffix_len;

437 ps_buffer_nosuffix_len = 0;

438

439 Assert(ps_buffer_cur_len == strlen(ps_buffer));

440

441

442 flush_ps_display();

443#endif

444}

445

446

447

448

449

450

451

452void

454{

456

457#ifndef PS_USE_NONE

458

459 if (!update_ps_display_precheck())

460 return;

461

462

463 ps_buffer_nosuffix_len = 0;

464

465

466 if (ps_buffer_fixed_size + len >= ps_buffer_size)

467 {

468

469 memcpy(ps_buffer + ps_buffer_fixed_size, activity,

470 ps_buffer_size - ps_buffer_fixed_size - 1);

471 ps_buffer[ps_buffer_size - 1] = '\0';

472 ps_buffer_cur_len = ps_buffer_size - 1;

473 }

474 else

475 {

476 memcpy(ps_buffer + ps_buffer_fixed_size, activity, len + 1);

477 ps_buffer_cur_len = ps_buffer_fixed_size + len;

478 }

479 Assert(strlen(ps_buffer) == ps_buffer_cur_len);

480

481

482 flush_ps_display();

483#endif

484}

485

486#ifndef PS_USE_NONE

487static void

488flush_ps_display(void)

489{

490#ifdef PS_USE_SETPROCTITLE

491 setproctitle("%s", ps_buffer);

492#elif defined(PS_USE_SETPROCTITLE_FAST)

493 setproctitle_fast("%s", ps_buffer);

494#endif

495

496#ifdef PS_USE_CLOBBER_ARGV

497

498 if (last_status_len > ps_buffer_cur_len)

500 last_status_len - ps_buffer_cur_len);

501 last_status_len = ps_buffer_cur_len;

502#endif

503

504#ifdef PS_USE_WIN32

505 {

506

507

508

509

510

511 static HANDLE ident_handle = INVALID_HANDLE_VALUE;

512 char name[PS_BUFFER_SIZE + 32];

513

514 if (ident_handle != INVALID_HANDLE_VALUE)

515 CloseHandle(ident_handle);

516

518

519 ident_handle = CreateEvent(NULL, TRUE, FALSE, name);

520 }

521#endif

522}

523#endif

524

525

526

527

528

529

530

531const char *

533{

534#ifdef PS_USE_CLOBBER_ARGV

535

536 if (!ps_buffer)

537 {

538 *displen = 0;

539 return "";

540 }

541#endif

542

543#ifndef PS_USE_NONE

544 *displen = (int) (ps_buffer_cur_len - ps_buffer_fixed_size);

545

546 return ps_buffer + ps_buffer_fixed_size;

547#else

548 *displen = 0;

549 return "";

550#endif

551}

#define write_stderr(str)

#define MemSet(start, val, len)

Assert(PointerIsAligned(start, uint64))

const char * GetBackendTypeDesc(BackendType backendType)

BackendType MyBackendType

const char * get_ps_display(int *displen)

void set_ps_display_remove_suffix(void)

void set_ps_display_with_len(const char *activity, size_t len)

void init_ps_display(const char *fixed_part)

void set_ps_display_suffix(const char *suffix)

bool update_process_title

char ** save_ps_display_args(int argc, char **argv)

static void set_ps_display(const char *activity)

#define DEFAULT_UPDATE_PROCESS_TITLE