?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Version 7.6.3.2-android, tag libreoffice-7.6.3.2-android
[LibreOffice.git] / sal / osl / unx / process.cxx
blob7d6936265c0b6aa29bf1e8cfbf279b2e0b64ca0b
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <sal/config.h>
21 #include <rtl/ustring.hxx>
22
23 #include <cassert>
24
25 /*
26 * ToDo:
27 * - cleanup of process status things
28 * - cleanup of process spawning
29 * - cleanup of resource transfer
30 */
31
32 #if defined(__sun)
33 // The procfs may only be used without LFS in 32bits.
34 # ifdef _FILE_OFFSET_BITS
35 # undef _FILE_OFFSET_BITS
36 # endif
37 #endif
38
39 #if defined(FREEBSD) || defined(NETBSD) || defined(DRAGONFLY)
40 #include <machine/param.h>
41 #endif
42
43 #include "system.hxx"
44 #include "unixerrnostring.hxx"
45 #if defined(__sun)
46 # include <sys/procfs.h>
47 #endif
48 #include <osl/diagnose.h>
49 #include <osl/mutex.h>
50 #include <osl/process.h>
51 #include <osl/conditn.h>
52 #include <osl/thread.h>
53 #include <osl/file.h>
54 #include <osl/file.hxx>
55 #include <osl/signal.h>
56 #include <rtl/alloc.h>
57 #include <sal/log.hxx>
58
59 #include <grp.h>
60
61 #include "createfilehandlefromfd.hxx"
62 #include "file_url.hxx"
63 #include "readwrite_helper.hxx"
64 #include "sockimpl.hxx"
65 #include "secimpl.hxx"
66
67 #define MAX_ARGS 255
68 #define MAX_ENVS 255
69
70 namespace
71 {
72
73 struct oslProcessImpl {
74 pid_t m_pid;
75 oslCondition m_terminated;
76 int m_status;
77 oslProcessImpl* m_pnext;
78 };
79
80 struct ProcessData
81 {
82 const char* m_pszArgs[MAX_ARGS + 1];
83 const char* m_pszDir;
84 char* m_pszEnv[MAX_ENVS + 1];
85 uid_t m_uid;
86 gid_t m_gid;
87 char* m_name;
88 oslCondition m_started;
89 oslProcessImpl* m_pProcImpl;
90 oslFileHandle *m_pInputWrite;
91 oslFileHandle *m_pOutputRead;
92 oslFileHandle *m_pErrorRead;
93 };
94
95 oslProcessImpl* ChildList;
96 oslMutex ChildListMutex;
97
98 } //Anonymous namespace
99
100 static oslProcessError osl_psz_executeProcess(char *pszImageName,
101 char *pszArguments[],
102 oslProcessOption Options,
103 oslSecurity Security,
104 char *pszDirectory,
105 char *pszEnvironments[],
106 oslProcess *pProcess,
107 oslFileHandle *pInputWrite,
108 oslFileHandle *pOutputRead,
109 oslFileHandle *pErrorRead );
110
111 extern "C" {
112
113 static void ChildStatusProc(void *pData)
114 {
115 osl_setThreadName("osl_executeProcess");
116
117 pid_t pid = -1;
118 int status = 0;
119 int channel[2] = { -1, -1 };
120 ProcessData data;
121 ProcessData *pdata;
122 int stdOutput[2] = { -1, -1 }, stdInput[2] = { -1, -1 }, stdError[2] = { -1, -1 };
123
124 pdata = static_cast<ProcessData *>(pData);
125
126 /* make a copy of our data, because forking will only copy
127 our local stack of the thread, so the process data will not be accessible
128 in our child process */
129 memcpy(&data, pData, sizeof(data));
130
131 #ifdef NO_CHILD_PROCESSES
132 #define fork() (errno = EINVAL, -1)
133 #endif
134 if (socketpair(AF_UNIX, SOCK_STREAM, 0, channel) == -1)
135 {
136 status = errno;
137 SAL_WARN("sal.osl", "executeProcess socketpair() errno " << status);
138 }
139
140 (void) fcntl(channel[0], F_SETFD, FD_CLOEXEC);
141 (void) fcntl(channel[1], F_SETFD, FD_CLOEXEC);
142
143 /* Create redirected IO pipes */
144 if ( status == 0 && data.m_pInputWrite && pipe( stdInput ) == -1 )
145 {
146 status = errno;
147 assert(status != 0);
148 SAL_WARN("sal.osl", "executeProcess pipe(stdInput) errno " << status);
149 }
150
151 if ( status == 0 && data.m_pOutputRead && pipe( stdOutput ) == -1 )
152 {
153 status = errno;
154 assert(status != 0);
155 SAL_WARN("sal.osl", "executeProcess pipe(stdOutput) errno " << status);
156 }
157
158 if ( status == 0 && data.m_pErrorRead && pipe( stdError ) == -1 )
159 {
160 status = errno;
161 assert(status != 0);
162 SAL_WARN("sal.osl", "executeProcess pipe(stdError) errno " << status);
163 }
164
165 if ( (status == 0) && ((pid = fork()) == 0) )
166 {
167 /* Child */
168 int chstatus = 0;
169 int errno_copy;
170
171 if (channel[0] != -1) close(channel[0]);
172
173 if ((data.m_uid != uid_t(-1)) && ((data.m_uid != getuid()) || (data.m_gid != getgid())))
174 {
175 OSL_ASSERT(geteuid() == 0); /* must be root */
176
177 if (! INIT_GROUPS(data.m_name, data.m_gid) || (setuid(data.m_uid) != 0))
178 {
179 // ignore; can't do much about it here after fork
180 }
181
182 unsetenv("HOME");
183 }
184
185 if (data.m_pszDir)
186 chstatus = chdir(data.m_pszDir);
187
188 if (chstatus == 0 && ((data.m_uid == uid_t(-1)) || ((data.m_uid == getuid()) && (data.m_gid == getgid()))))
189 {
190 int i;
191 for (i = 0; data.m_pszEnv[i] != nullptr; i++)
192 {
193 if (strchr(data.m_pszEnv[i], '=') == nullptr)
194 {
195 unsetenv(data.m_pszEnv[i]); /*TODO: check error return*/
196 }
197 else
198 {
199 putenv(data.m_pszEnv[i]); /*TODO: check error return*/
200 }
201 }
202
203 /* Connect std IO to pipe ends */
204
205 /* Write end of stdInput not used in child process */
206 if (stdInput[1] != -1) close( stdInput[1] );
207
208 /* Read end of stdOutput not used in child process */
209 if (stdOutput[0] != -1) close( stdOutput[0] );
210
211 /* Read end of stdError not used in child process */
212 if (stdError[0] != -1) close( stdError[0] );
213
214 /* Redirect pipe ends to std IO */
215
216 if ( stdInput[0] != STDIN_FILENO )
217 {
218 dup2( stdInput[0], STDIN_FILENO );
219 if (stdInput[0] != -1) close( stdInput[0] );
220 }
221
222 if ( stdOutput[1] != STDOUT_FILENO )
223 {
224 dup2( stdOutput[1], STDOUT_FILENO );
225 if (stdOutput[1] != -1) close( stdOutput[1] );
226 }
227
228 if ( stdError[1] != STDERR_FILENO )
229 {
230 dup2( stdError[1], STDERR_FILENO );
231 if (stdError[1] != -1) close( stdError[1] );
232 }
233
234 // No need to check the return value of execv. If we return from
235 // it, an error has occurred.
236 execv(data.m_pszArgs[0], const_cast<char **>(data.m_pszArgs));
237 }
238
239 /* if we reach here, something went wrong */
240 errno_copy = errno;
241 if ( !safeWrite(channel[1], &errno_copy, sizeof(errno_copy)) )
242 {
243 // ignore; can't do much about it here after fork
244 }
245
246 if ( channel[1] != -1 )
247 close(channel[1]);
248
249 _exit(255);
250 }
251 else
252 { /* Parent */
253 int i = -1;
254 if (channel[1] != -1) close(channel[1]);
255
256 /* Close unused pipe ends */
257 if (stdInput[0] != -1) close( stdInput[0] );
258 if (stdOutput[1] != -1) close( stdOutput[1] );
259 if (stdError[1] != -1) close( stdError[1] );
260
261 if (pid > 0)
262 {
263 while ((i = read(channel[0], &status, sizeof(status))) < 0)
264 {
265 if (errno != EINTR)
266 break;
267 }
268 }
269
270 if (channel[0] != -1) close(channel[0]);
271
272 if ((pid > 0) && (i == 0))
273 {
274 pid_t child_pid;
275 osl_acquireMutex(ChildListMutex);
276
277 pdata->m_pProcImpl->m_pid = pid;
278 pdata->m_pProcImpl->m_pnext = ChildList;
279 ChildList = pdata->m_pProcImpl;
280
281 /* Store used pipe ends in data structure */
282
283 if ( pdata->m_pInputWrite )
284 *(pdata->m_pInputWrite) = osl::detail::createFileHandleFromFD( stdInput[1] );
285
286 if ( pdata->m_pOutputRead )
287 *(pdata->m_pOutputRead) = osl::detail::createFileHandleFromFD( stdOutput[0] );
288
289 if ( pdata->m_pErrorRead )
290 *(pdata->m_pErrorRead) = osl::detail::createFileHandleFromFD( stdError[0] );
291
292 osl_releaseMutex(ChildListMutex);
293
294 osl_setCondition(pdata->m_started);
295
296 do
297 {
298 child_pid = waitpid(pid, &status, 0);
299 } while ( 0 > child_pid && EINTR == errno );
300
301 if ( child_pid < 0)
302 {
303 SAL_WARN("sal.osl", "Failed to wait for child process: " << UnixErrnoString(errno));
304
305 /*
306 We got another error than EINTR. Anyway we have to wake up the
307 waiting thread under any circumstances */
308
309 child_pid = pid;
310 }
311
312 if ( child_pid > 0 )
313 {
314 oslProcessImpl* pChild;
315
316 osl_acquireMutex(ChildListMutex);
317
318 pChild = ChildList;
319
320 /* check if it is one of our child processes */
321 while (pChild != nullptr)
322 {
323 if (pChild->m_pid == child_pid)
324 {
325 if (WIFEXITED(status))
326 pChild->m_status = WEXITSTATUS(status);
327 else if (WIFSIGNALED(status))
328 pChild->m_status = 128 + WTERMSIG(status);
329 else
330 pChild->m_status = -1;
331
332 // coverity[lock_order : FALSE] - incorrect report of lock order error
333 osl_setCondition(pChild->m_terminated);
334 }
335
336 pChild = pChild->m_pnext;
337 }
338
339 osl_releaseMutex(ChildListMutex);
340 }
341 }
342 else
343 {
344 SAL_WARN("sal.osl", "ChildStatusProc : starting '" << data.m_pszArgs[0] << "' failed");
345 SAL_WARN("sal.osl", "Failed to launch child process, child reports " << UnixErrnoString(status));
346
347 /* Close pipe ends */
348 if ( pdata->m_pInputWrite )
349 *pdata->m_pInputWrite = nullptr;
350
351 if ( pdata->m_pOutputRead )
352 *pdata->m_pOutputRead = nullptr;
353
354 if ( pdata->m_pErrorRead )
355 *pdata->m_pErrorRead = nullptr;
356
357 if (stdInput[1] != -1) close( stdInput[1] );
358 if (stdOutput[0] != -1) close( stdOutput[0] );
359 if (stdError[0] != -1) close( stdError[0] );
360
361 /* if pid > 0 then a process was created, even if it later failed
362 e.g. bash searching for a command to execute, and we still
363 need to clean it up to avoid "defunct" processes */
364 if (pid > 0)
365 {
366 pid_t child_pid;
367 do
368 {
369 child_pid = waitpid(pid, &status, 0);
370 } while ( 0 > child_pid && EINTR == errno );
371 }
372
373 /* notify (and unblock) parent thread */
374 osl_setCondition(pdata->m_started);
375 }
376 }
377 }
378
379 }
380
381 oslProcessError SAL_CALL osl_executeProcess_WithRedirectedIO(
382 rtl_uString *ustrImageName,
383 rtl_uString *ustrArguments[],
384 sal_uInt32 nArguments,
385 oslProcessOption Options,
386 oslSecurity Security,
387 rtl_uString *ustrWorkDir,
388 rtl_uString *ustrEnvironment[],
389 sal_uInt32 nEnvironmentVars,
390 oslProcess *pProcess,
391 oslFileHandle *pInputWrite,
392 oslFileHandle *pOutputRead,
393 oslFileHandle *pErrorRead
394 )
395 {
396 OUString image;
397 if (ustrImageName == nullptr)
398 {
399 if (nArguments == 0)
400 {
401 return osl_Process_E_InvalidError;
402 }
403 image = OUString::unacquired(ustrArguments);
404 }
405 else
406 {
407 osl::FileBase::RC e = osl::FileBase::getSystemPathFromFileURL(
408 OUString::unacquired(&ustrImageName), image);
409 if (e != osl::FileBase::E_None)
410 {
411 SAL_INFO(
412 "sal.osl",
413 "getSystemPathFromFileURL("
414 << OUString::unacquired(&ustrImageName)
415 << ") failed with " << e);
416 return osl_Process_E_Unknown;
417 }
418 }
419
420 if ((Options & osl_Process_SEARCHPATH) != 0)
421 {
422 OUString path;
423 if (osl::detail::find_in_PATH(image, path))
424 {
425 image = path;
426 }
427 }
428
429 oslProcessError Error;
430 char* pszWorkDir=nullptr;
431 char** pArguments=nullptr;
432 char** pEnvironment=nullptr;
433 unsigned int idx;
434
435 char szImagePath[PATH_MAX] = "";
436 if (!image.isEmpty()
437 && (UnicodeToText(
438 szImagePath, SAL_N_ELEMENTS(szImagePath), image.getStr(),
439 image.getLength())
440 == 0))
441 {
442 int e = errno;
443 SAL_INFO("sal.osl", "UnicodeToText(" << image << ") failed with " << e);
444 return osl_Process_E_Unknown;
445 }
446
447 char szWorkDir[PATH_MAX] = "";
448 if ( ustrWorkDir != nullptr && ustrWorkDir->length )
449 {
450 oslFileError e = FileURLToPath( szWorkDir, PATH_MAX, ustrWorkDir );
451 if (e != osl_File_E_None)
452 {
453 SAL_INFO(
454 "sal.osl",
455 "FileURLToPath(" << OUString::unacquired(&ustrWorkDir)
456 << ") failed with " << e);
457 return osl_Process_E_Unknown;
458 }
459 pszWorkDir = szWorkDir;
460 }
461
462 if ( pArguments == nullptr && nArguments > 0 )
463 {
464 pArguments = static_cast<char**>(malloc( ( nArguments + 2 ) * sizeof(char*) ));
465 }
466
467 for ( idx = 0 ; idx < nArguments ; ++idx )
468 {
469 rtl_String* strArg =nullptr;
470
471 rtl_uString2String( &strArg,
472 rtl_uString_getStr(ustrArguments[idx]),
473 rtl_uString_getLength(ustrArguments[idx]),
474 osl_getThreadTextEncoding(),
475 OUSTRING_TO_OSTRING_CVTFLAGS );
476
477 pArguments[idx]=strdup(rtl_string_getStr(strArg));
478 rtl_string_release(strArg);
479 pArguments[idx+1]=nullptr;
480 }
481
482 for ( idx = 0 ; idx < nEnvironmentVars ; ++idx )
483 {
484 rtl_String* strEnv=nullptr;
485
486 if ( pEnvironment == nullptr )
487 {
488 pEnvironment = static_cast<char**>(malloc( ( nEnvironmentVars + 2 ) * sizeof(char*) ));
489 }
490
491 rtl_uString2String( &strEnv,
492 rtl_uString_getStr(ustrEnvironment[idx]),
493 rtl_uString_getLength(ustrEnvironment[idx]),
494 osl_getThreadTextEncoding(),
495 OUSTRING_TO_OSTRING_CVTFLAGS );
496
497 pEnvironment[idx]=strdup(rtl_string_getStr(strEnv));
498 rtl_string_release(strEnv);
499 pEnvironment[idx+1]=nullptr;
500 }
501
502 Error = osl_psz_executeProcess(szImagePath,
503 pArguments,
504 Options,
505 Security,
506 pszWorkDir,
507 pEnvironment,
508 pProcess,
509 pInputWrite,
510 pOutputRead,
511 pErrorRead
512 );
513
514 if ( pArguments != nullptr )
515 {
516 for ( idx = 0 ; idx < nArguments ; ++idx )
517 {
518 if ( pArguments[idx] != nullptr )
519 {
520 free(pArguments[idx]);
521 }
522 }
523 free(pArguments);
524 }
525
526 if ( pEnvironment != nullptr )
527 {
528 for ( idx = 0 ; idx < nEnvironmentVars ; ++idx )
529 {
530 if ( pEnvironment[idx] != nullptr )
531 {
532 free(pEnvironment[idx]);
533 }
534 }
535 free(pEnvironment);
536 }
537
538 return Error;
539 }
540
541 oslProcessError SAL_CALL osl_executeProcess(
542 rtl_uString *ustrImageName,
543 rtl_uString *ustrArguments[],
544 sal_uInt32 nArguments,
545 oslProcessOption Options,
546 oslSecurity Security,
547 rtl_uString *ustrWorkDir,
548 rtl_uString *ustrEnvironment[],
549 sal_uInt32 nEnvironmentVars,
550 oslProcess *pProcess
551 )
552 {
553 return osl_executeProcess_WithRedirectedIO(
554 ustrImageName,
555 ustrArguments,
556 nArguments,
557 Options,
558 Security,
559 ustrWorkDir,
560 ustrEnvironment,
561 nEnvironmentVars,
562 pProcess,
563 nullptr,
564 nullptr,
565 nullptr
566 );
567 }
568
569 oslProcessError osl_psz_executeProcess(char *pszImageName,
570 char *pszArguments[],
571 oslProcessOption Options,
572 oslSecurity Security,
573 char *pszDirectory,
574 char *pszEnvironments[],
575 oslProcess *pProcess,
576 oslFileHandle *pInputWrite,
577 oslFileHandle *pOutputRead,
578 oslFileHandle *pErrorRead
579 )
580 {
581 int i;
582 ProcessData Data;
583 oslThread hThread;
584
585 memset(&Data,0,sizeof(ProcessData));
586 Data.m_pInputWrite = pInputWrite;
587 Data.m_pOutputRead = pOutputRead;
588 Data.m_pErrorRead = pErrorRead;
589
590 OSL_ASSERT(pszImageName != nullptr);
591
592 if ( pszImageName == nullptr )
593 {
594 return osl_Process_E_NotFound;
595 }
596
597 Data.m_pszArgs[0] = strdup(pszImageName);
598 Data.m_pszArgs[1] = nullptr;
599
600 if ( pszArguments != nullptr )
601 {
602 for (i = 0; ((i + 2) < MAX_ARGS) && (pszArguments[i] != nullptr); i++)
603 Data.m_pszArgs[i+1] = strdup(pszArguments[i]);
604 Data.m_pszArgs[i+2] = nullptr;
605 }
606
607 Data.m_pszDir = (pszDirectory != nullptr) ? strdup(pszDirectory) : nullptr;
608
609 if (pszEnvironments != nullptr)
610 {
611 for (i = 0; ((i + 1) < MAX_ENVS) && (pszEnvironments[i] != nullptr); i++)
612 Data.m_pszEnv[i] = strdup(pszEnvironments[i]);
613 Data.m_pszEnv[i+1] = nullptr;
614 }
615 else
616 Data.m_pszEnv[0] = nullptr;
617
618 if (Security != nullptr)
619 {
620 Data.m_uid = static_cast<oslSecurityImpl*>(Security)->m_pPasswd.pw_uid;
621 Data.m_gid = static_cast<oslSecurityImpl*>(Security)->m_pPasswd.pw_gid;
622 Data.m_name = static_cast<oslSecurityImpl*>(Security)->m_pPasswd.pw_name;
623 }
624 else
625 Data.m_uid = uid_t(-1);
626
627 Data.m_pProcImpl = static_cast<oslProcessImpl*>(malloc(sizeof(oslProcessImpl)));
628 Data.m_pProcImpl->m_pid = 0;
629 Data.m_pProcImpl->m_terminated = osl_createCondition();
630 Data.m_pProcImpl->m_pnext = nullptr;
631
632 if (ChildListMutex == nullptr)
633 ChildListMutex = osl_createMutex();
634
635 Data.m_started = osl_createCondition();
636
637 hThread = osl_createThread(ChildStatusProc, &Data);
638
639 if (hThread != nullptr)
640 {
641 osl_waitCondition(Data.m_started, nullptr);
642 }
643 osl_destroyCondition(Data.m_started);
644
645 for (i = 0; Data.m_pszArgs[i] != nullptr; i++)
646 free(const_cast<char *>(Data.m_pszArgs[i]));
647
648 for (i = 0; Data.m_pszEnv[i] != nullptr; i++)
649 free(Data.m_pszEnv[i]);
650
651 if ( Data.m_pszDir != nullptr )
652 {
653 free(const_cast<char *>(Data.m_pszDir));
654 }
655
656 osl_destroyThread(hThread);
657
658 if (Data.m_pProcImpl->m_pid != 0)
659 {
660 assert(hThread != nullptr);
661
662 *pProcess = Data.m_pProcImpl;
663
664 if (Options & osl_Process_WAIT)
665 osl_joinProcess(*pProcess);
666
667 return osl_Process_E_None;
668 }
669
670 osl_destroyCondition(Data.m_pProcImpl->m_terminated);
671 free(Data.m_pProcImpl);
672
673 return osl_Process_E_Unknown;
674 }
675
676 oslProcessError SAL_CALL osl_terminateProcess(oslProcess Process)
677 {
678 if (Process == nullptr)
679 return osl_Process_E_Unknown;
680
681 if (kill(static_cast<oslProcessImpl*>(Process)->m_pid, SIGKILL) != 0)
682 {
683 switch (errno)
684 {
685 case EPERM:
686 return osl_Process_E_NoPermission;
687
688 case ESRCH:
689 return osl_Process_E_NotFound;
690
691 default:
692 return osl_Process_E_Unknown;
693 }
694 }
695
696 return osl_Process_E_None;
697 }
698
699 oslProcess SAL_CALL osl_getProcess(oslProcessIdentifier Ident)
700 {
701 oslProcessImpl *pProcImpl;
702
703 if (kill(Ident, 0) != -1)
704 {
705 oslProcessImpl* pChild;
706
707 if (ChildListMutex == nullptr)
708 ChildListMutex = osl_createMutex();
709
710 osl_acquireMutex(ChildListMutex);
711
712 pChild = ChildList;
713
714 /* check if it is one of our child processes */
715 while (pChild != nullptr)
716 {
717 if (Ident == static_cast<sal_uInt32>(pChild->m_pid))
718 break;
719
720 pChild = pChild->m_pnext;
721 }
722
723 pProcImpl = static_cast<oslProcessImpl*>(malloc(sizeof(oslProcessImpl)));
724 pProcImpl->m_pid = Ident;
725 pProcImpl->m_terminated = osl_createCondition();
726
727 if (pChild != nullptr)
728 {
729 /* process is a child so insert into list */
730 pProcImpl->m_pnext = pChild->m_pnext;
731 pChild->m_pnext = pProcImpl;
732
733 pProcImpl->m_status = pChild->m_status;
734
735 // coverity[lock_order : FALSE] - incorrect report of lock order error
736 if (osl_checkCondition(pChild->m_terminated))
737 {
738 // coverity[lock_order : FALSE] - incorrect report of lock order error
739 osl_setCondition(pProcImpl->m_terminated);
740 }
741 }
742 else
743 pProcImpl->m_pnext = nullptr;
744
745 osl_releaseMutex(ChildListMutex);
746 }
747 else
748 pProcImpl = nullptr;
749
750 return pProcImpl;
751 }
752
753 void SAL_CALL osl_freeProcessHandle(oslProcess Process)
754 {
755 if (Process == nullptr)
756 return;
757
758 oslProcessImpl *pChild, *pPrev = nullptr;
759
760 OSL_ASSERT(ChildListMutex != nullptr);
761
762 if ( ChildListMutex == nullptr )
763 {
764 return;
765 }
766
767 osl_acquireMutex(ChildListMutex);
768
769 pChild = ChildList;
770
771 /* remove process from child list */
772 while (pChild != nullptr)
773 {
774 if (pChild == static_cast<oslProcessImpl*>(Process))
775 {
776 if (pPrev != nullptr)
777 pPrev->m_pnext = pChild->m_pnext;
778 else
779 ChildList = pChild->m_pnext;
780
781 break;
782 }
783
784 pPrev = pChild;
785 pChild = pChild->m_pnext;
786 }
787
788 osl_releaseMutex(ChildListMutex);
789
790 osl_destroyCondition(static_cast<oslProcessImpl*>(Process)->m_terminated);
791
792 free(Process);
793 }
794
795 #if defined(LINUX)
796 namespace {
797
798 struct osl_procStat
799 {
800 /* from 'stat' */
801 pid_t pid; /* pid */
802 char command[16]; /* 'argv[0]' */ /* mfe: it all right char comm[16] in kernel! */
803 char state; /* state (running, stopped, ...) */
804 pid_t ppid; /* parent pid */
805 pid_t pgrp; /* parent group */
806 int session; /* session ID */
807 int tty; /* no of tty */
808 pid_t tpgid; /* group of process owning the tty */
809 unsigned long flags; /* flags dunno */
810 unsigned long minflt; /* minor page faults */
811 unsigned long cminflt; /* minor page faults with children */
812 unsigned long majflt; /* major page faults */
813 unsigned long cmajflt; /* major page faults with children */
814 unsigned long utime; /* no of jiffies in user mode */
815 unsigned long stime; /* no of jiffies in kernel mode */
816 unsigned long cutime; /* no of jiffies in user mode with children */
817 unsigned long cstime; /* no of jiffies in kernel mode with children */
818 unsigned long priority; /* nice value + 15 (kernel scheduling prio)*/
819 long nice; /* nice value */
820 long timeout; /* no of jiffies of next process timeout */
821 long itrealvalue; /* no jiffies before next SIGALRM */
822 unsigned long starttime; /* process started this no of jiffies after boot */
823 unsigned long vsize; /* virtual memory size (in bytes) */
824 long rss; /* resident set size (in pages) */
825 unsigned long rss_rlim; /* rss limit (in bytes) */
826 unsigned long startcode; /* address above program text can run */
827 unsigned long endcode; /* address below program text can run */
828 unsigned long startstack; /* address of start of stack */
829 unsigned long kstkesp; /* current value of 'esp' (stack pointer) */
830 unsigned long kstkeip; /* current value of 'eip' (instruction pointer) */
831 /* mfe: Linux > 2.1.7x have more signals (88) */
832 char signal[24]; /* pending signals */
833 char blocked[24]; /* blocked signals */
834 char sigignore[24]; /* ignored signals */
835 char sigcatch[24]; /* caught signals */
836 unsigned long wchan; /* 'channel' the process is waiting in */
837 unsigned long nswap; /* ? */
838 unsigned long cnswap; /* ? */
839
840 /* from 'status' */
841 int ruid; /* real uid */
842 int euid; /* effective uid */
843 int suid; /* saved uid */
844 int fuid; /* file access uid */
845 int rgid; /* real gid */
846 int egid; /* effective gid */
847 int sgid; /* saved gid */
848 int fgid; /* file access gid */
849 unsigned long vm_size; /* like vsize but on kb */
850 unsigned long vm_lock; /* locked pages in kb */
851 unsigned long vm_rss; /* like rss but in kb */
852 unsigned long vm_data; /* data size */
853 unsigned long vm_stack; /* stack size */
854 unsigned long vm_exe; /* executable size */
855 unsigned long vm_lib; /* library size */
856 };
857
858 }
859
860 static bool osl_getProcStat(pid_t pid, struct osl_procStat* procstat)
861 {
862 int fd = 0;
863 bool bRet = false;
864 char name[PATH_MAX + 1];
865 snprintf(name, sizeof(name), "/proc/%u/stat", pid);
866
867 if ((fd = open(name,O_RDONLY)) >=0 )
868 {
869 char* tmp=nullptr;
870 char prstatbuf[512];
871 memset(prstatbuf,0,512);
872 bRet = safeRead(fd, prstatbuf, 511);
873
874 close(fd);
875
876 if (!bRet)
877 return false;
878
879 tmp = strrchr(prstatbuf, ')');
880 if(tmp)
881 {
882 *tmp = '\0';
883
884 memset(procstat->command, 0, sizeof(procstat->command));
885
886 sscanf(prstatbuf, "%d (%15c", &procstat->pid, procstat->command);
887 sscanf(tmp + 2,
888 "%c"
889 "%i %i %i %i %i"
890 "%lu %lu %lu %lu %lu"
891 "%lu %lu %lu %lu"
892 "%lu %li %li %li"
893 "%lu %lu %li %lu"
894 "%lu %lu %lu %lu %lu"
895 "%23s %23s %23s %23s"
896 "%lu %lu %lu",
897 &procstat->state,
898 &procstat->ppid, &procstat->pgrp, &procstat->session, &procstat->tty, &procstat->tpgid,
899 &procstat->flags, &procstat->minflt, &procstat->cminflt, &procstat->majflt, &procstat->cmajflt,
900 &procstat->utime, &procstat->stime, &procstat->cutime, &procstat->cstime,
901 &procstat->priority, &procstat->nice, &procstat->timeout, &procstat->itrealvalue,
902 &procstat->starttime, &procstat->vsize, &procstat->rss, &procstat->rss_rlim,
903 &procstat->startcode, &procstat->endcode, &procstat->startstack, &procstat->kstkesp, &procstat->kstkeip,
904 procstat->signal, procstat->blocked, procstat->sigignore, procstat->sigcatch,
905 &procstat->wchan, &procstat->nswap, &procstat->cnswap
906 );
907 }
908 else
909 {
910 bRet = false;
911 }
912 }
913 return bRet;
914 }
915
916 static bool osl_getProcStatus(pid_t pid, struct osl_procStat* procstat)
917 {
918 int fd = 0;
919 char name[PATH_MAX + 1];
920 bool bRet = false;
921
922 snprintf(name, sizeof(name), "/proc/%u/status", pid);
923
924 if ((fd = open(name,O_RDONLY)) >=0 )
925 {
926 char* tmp=nullptr;
927 char prstatusbuf[512];
928 memset(prstatusbuf,0,512);
929 bRet = safeRead(fd, prstatusbuf, 511);
930
931 close(fd);
932
933 if (!bRet)
934 return false;
935
936 tmp = strstr(prstatusbuf,"Uid:");
937 if(tmp)
938 {
939 sscanf(tmp,"Uid:\t%d\t%d\t%d\t%d",
940 &procstat->ruid, &procstat->euid, &procstat->suid, &procstat->fuid
941 );
942 }
943
944 tmp = strstr(prstatusbuf,"Gid:");
945 if(tmp)
946 {
947 sscanf(tmp,"Gid:\t%d\t%d\t%d\t%d",
948 &procstat->rgid, &procstat->egid, &procstat->sgid, &procstat->fgid
949 );
950 }
951
952 tmp = strstr(prstatusbuf,"VmSize:");
953 if(tmp)
954 {
955 sscanf(tmp,
956 "VmSize: %lu kB\n"
957 "VmLck: %lu kB\n"
958 "VmRSS: %lu kB\n"
959 "VmData: %lu kB\n"
960 "VmStk: %lu kB\n"
961 "VmExe: %lu kB\n"
962 "VmLib: %lu kB\n",
963 &procstat->vm_size, &procstat->vm_lock, &procstat->vm_rss, &procstat->vm_data,
964 &procstat->vm_stack, &procstat->vm_exe, &procstat->vm_lib
965 );
966 }
967
968 tmp = strstr(prstatusbuf,"SigPnd:");
969 if(tmp)
970 {
971 sscanf(tmp, "SigPnd: %23s SigBlk: %23s SigIgn: %23s %*s %23s",
972 procstat->signal, procstat->blocked, procstat->sigignore, procstat->sigcatch
973 );
974 }
975 }
976 return bRet;
977 }
978
979 #endif
980
981 oslProcessError SAL_CALL osl_getProcessInfo(oslProcess Process, oslProcessData Fields, oslProcessInfo* pInfo)
982 {
983 pid_t pid;
984
985 if (Process == nullptr)
986 pid = getpid();
987 else
988 pid = static_cast<oslProcessImpl*>(Process)->m_pid;
989
990 if (! pInfo || (pInfo->Size != sizeof(oslProcessInfo)))
991 return osl_Process_E_Unknown;
992
993 pInfo->Fields = 0;
994
995 if (Fields & osl_Process_IDENTIFIER)
996 {
997 pInfo->Ident = pid;
998 pInfo->Fields |= osl_Process_IDENTIFIER;
999 }
1000
1001 if (Fields & osl_Process_EXITCODE)
1002 {
1003 if ((Process != nullptr) &&
1004 osl_checkCondition(static_cast<oslProcessImpl*>(Process)->m_terminated))
1005 {
1006 pInfo->Code = static_cast<oslProcessImpl*>(Process)->m_status;
1007 pInfo->Fields |= osl_Process_EXITCODE;
1008 }
1009 }
1010
1011 if (Fields & (osl_Process_HEAPUSAGE | osl_Process_CPUTIMES))
1012 {
1013
1014 #if defined(__sun)
1015
1016 int fd;
1017 char name[PATH_MAX + 1];
1018
1019 snprintf(name, sizeof(name), "/proc/%ld", (long)pid);
1020
1021 if ((fd = open(name, O_RDONLY)) >= 0)
1022 {
1023 prstatus_t prstatus;
1024
1025 if (ioctl(fd, PIOCSTATUS, &prstatus) >= 0)
1026 {
1027 if (Fields & osl_Process_CPUTIMES)
1028 {
1029 pInfo->UserTime.Seconds = prstatus.pr_utime.tv_sec;
1030 pInfo->UserTime.Nanosec = prstatus.pr_utime.tv_nsec;
1031 pInfo->SystemTime.Seconds = prstatus.pr_stime.tv_sec;
1032 pInfo->SystemTime.Nanosec = prstatus.pr_stime.tv_nsec;
1033
1034 pInfo->Fields |= osl_Process_CPUTIMES;
1035 }
1036
1037 if (Fields & osl_Process_HEAPUSAGE)
1038 {
1039 pInfo->HeapUsage = prstatus.pr_brksize;
1040
1041 pInfo->Fields |= osl_Process_HEAPUSAGE;
1042 }
1043
1044 close(fd);
1045
1046 return (pInfo->Fields == Fields) ? osl_Process_E_None : osl_Process_E_Unknown;
1047 }
1048 else
1049 close(fd);
1050 }
1051
1052 #elif defined(LINUX)
1053
1054 if ( (Fields & osl_Process_CPUTIMES) || (Fields & osl_Process_HEAPUSAGE) )
1055 {
1056 struct osl_procStat procstat;
1057 memset(&procstat,0,sizeof(procstat));
1058
1059 if ( (Fields & osl_Process_CPUTIMES) && osl_getProcStat(pid, &procstat) )
1060 {
1061 /*
1062 * mfe:
1063 * We calculate only time of the process proper.
1064 * Threads are processes, we do not consider their time here!
1065 * (For this, cutime and cstime should be used, it seems not
1066 * to work in 2.0.36)
1067 */
1068
1069 long clktck;
1070 unsigned long hz;
1071 unsigned long userseconds;
1072 unsigned long systemseconds;
1073
1074 clktck = sysconf(_SC_CLK_TCK);
1075 if (clktck <= 0) {
1076 return osl_Process_E_Unknown;
1077 }
1078 hz = static_cast<unsigned long>(clktck);
1079
1080 userseconds = procstat.utime/hz;
1081 systemseconds = procstat.stime/hz;
1082
1083 pInfo->UserTime.Seconds = userseconds;
1084 pInfo->UserTime.Nanosec = procstat.utime - (userseconds * hz);
1085 pInfo->SystemTime.Seconds = systemseconds;
1086 pInfo->SystemTime.Nanosec = procstat.stime - (systemseconds * hz);
1087
1088 pInfo->Fields |= osl_Process_CPUTIMES;
1089 }
1090
1091 if ( (Fields & osl_Process_HEAPUSAGE) && osl_getProcStatus(pid, &procstat) )
1092 {
1093 /*
1094 * mfe:
1095 * vm_data (found in status) shows the size of the data segment
1096 * it a rough approximation of the core heap size
1097 */
1098 pInfo->HeapUsage = procstat.vm_data*1024;
1099
1100 pInfo->Fields |= osl_Process_HEAPUSAGE;
1101 }
1102 }
1103
1104 return (pInfo->Fields == Fields) ? osl_Process_E_None : osl_Process_E_Unknown;
1105 #endif
1106
1107 }
1108
1109 return (pInfo->Fields == Fields) ? osl_Process_E_None : osl_Process_E_Unknown;
1110 }
1111
1112 /** Helper function for osl_joinProcessWithTimeout
1113 */
1114
1115 static bool is_timeout(const struct timeval* tend)
1116 {
1117 struct timeval tcurrent;
1118 gettimeofday(&tcurrent, nullptr);
1119 return (tcurrent.tv_sec >= tend->tv_sec);
1120 }
1121
1122 /* kill(pid, 0) is useful for checking if a
1123 process is still alive, but remember that
1124 kill even returns 0 if the process is already
1125 a zombie. */
1126
1127 static bool is_process_dead(pid_t pid)
1128 {
1129 return ((kill(pid, 0) == -1) && (ESRCH == errno));
1130 }
1131
1132 oslProcessError SAL_CALL osl_joinProcessWithTimeout(oslProcess Process, const TimeValue* pTimeout)
1133 {
1134 oslProcessImpl* pChild = ChildList;
1135 oslProcessError osl_error = osl_Process_E_None;
1136
1137 OSL_PRECOND(Process, "osl_joinProcess: Invalid parameter");
1138 OSL_ASSERT(ChildListMutex);
1139
1140 if (Process == nullptr || ChildListMutex == nullptr)
1141 return osl_Process_E_Unknown;
1142
1143 osl_acquireMutex(ChildListMutex);
1144
1145 /* check if process is a child of ours */
1146 while (pChild != nullptr)
1147 {
1148 if (pChild == static_cast<oslProcessImpl*>(Process))
1149 break;
1150
1151 pChild = pChild->m_pnext;
1152 }
1153
1154 osl_releaseMutex(ChildListMutex);
1155
1156 if (pChild != nullptr)
1157 {
1158 oslConditionResult cond_res = osl_waitCondition(pChild->m_terminated, pTimeout);
1159
1160 if (cond_res == osl_cond_result_timeout)
1161 osl_error = osl_Process_E_TimedOut;
1162 else if (cond_res != osl_cond_result_ok)
1163 osl_error = osl_Process_E_Unknown;
1164 }
1165 else /* alien process; StatusThread will not be able
1166 to set the condition terminated */
1167 {
1168 pid_t pid = static_cast<oslProcessImpl*>(Process)->m_pid;
1169
1170 if (pTimeout)
1171 {
1172 bool timeout = false;
1173 struct timeval tend;
1174
1175 gettimeofday(&tend, nullptr);
1176
1177 tend.tv_sec += pTimeout->Seconds;
1178
1179 while (!is_process_dead(pid) && !(timeout = is_timeout(&tend)))
1180 sleep(1);
1181
1182 if (timeout)
1183 osl_error = osl_Process_E_TimedOut;
1184 }
1185 else /* infinite */
1186 {
1187 while (!is_process_dead(pid))
1188 sleep(1);
1189 }
1190 }
1191 return osl_error;
1192 }
1193
1194 oslProcessError SAL_CALL osl_joinProcess(oslProcess Process)
1195 {
1196 return osl_joinProcessWithTimeout(Process, nullptr);
1197 }
1198
1199 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE