A. Private Process Management The fi

A. Private Process Management The first requirement for implementing PRIVEXEC is to enable the OS to support a private execution mode for processes. The OS must be able to launch an application as a private process upon request from the user, generate the PEK, store it in an easily accessible context associated with that process, mark the process and track it during its lifetime, and, finally, destroy the PEK when the private process ter- minates. Additionally, these new capabilities must not break the established kernel process management functionality. At the same time, the OS must expose a simple interface for user-level applications to request private execution without requiring modifications to existing application code. The Linux kernel represents every process on the system using a process descriptor, defined as struct task_struct in include/linux/sched.h. The process descriptor contains all the information required to execute the process, including functions such as scheduling, virtual address space management, and accounting. A new process, or child, is created by copying an existing process, or parent, through the fork and clone system calls. clone is a Linux-specific system call that offers fine-grained control over which system resources the parent and child share through a set of clone flags passed as an argument, and is typically used for creating threads. fork, on the other hand, defines a static set of clone flags to create independent pro- cesses with the usual POSIX semantics. These two system calls, in turn, invoke the function do_fork implemented in kernel/fork.c, which allocates a new process descriptor for the child, initializes it, and prepares it for scheduling. When the process is terminated, for example by invoking the exit system call, the function do_exit, implemented in kernel/exit.c, deallocates resources associated with the process. To implement our system, we first extended the process descriptor by defining a new process flag, PF_PRIVEXEC,
that is set in the flags field of the process descriptor to indicate that it is a private process. We defined a new flag, CLONE_PRIVEXEC, that is passed to clone whenever a privateprocessistobecreated.Weintroducedafieldtostore the PEK in the process descriptor called privexec_key. The final addition to the process descriptor was a pre- allocated cryptographic transform struct that is used for swap encryption. Here, we relied upon the Linux kernel’s cryptography framework (Crypto API); we defer details of its use to Section IV-C. To handle private process creation, we modified do_fork to check for the presence of CLONE_PRIVEXEC. In that case, we set the PF_PRIVEXEC flag, and generate a fresh PEK using a cryptographically-secure PRNG. The PEK is stored inside the process descriptor, resides in the kernel virtual address space, and is never disclosed to the user. For private process termination, we adapted do_exit to check for the presence of PF_PRIVEXEC in the flags bitset. If present, the process cryptographic transform is deallocated, and the PEK is securely wiped prior to freeing the process descriptor. Since the Linux kernel handles both processes and threads in the same functions, this approach also allows for creating and terminating private threads without any additional implementation effort. Note that applications might spawn additional children for creating subprocesses or threads during the course of execution. This can lead to two critical issues with multi-process and multi-threaded applications running under PRIVEXEC. First, public children of a private process could cause privacy leaks. Second, public children cannot access the parent’s secure container, which could potentially break the application. In order to prevent these problems, our notion of a private execution should include the full set of application processes and threads, despite the fact that the Linux kernel represents them with separate process descriptors. Therefore, we modified do_fork to ensure that all children of a private process inherit the parent’s private status and privacy context, including both the PEK and the secure storage container. Reference counting is used to ensure that resources are properly disposed of when the entire private process group exits. Also, note that our implementation exposes PRIVEXEC to user applications through a new clone flag that is passed to clone. As a result, when the private execution flag is not passed to the system call, the original semantics of fork and clone are preserved, maintaining full compatibility with existing applications. Likewise, applications that are not aware of the newly implemented PRIVEXEC interface to clone could be made private by simply wrapping their executables with a program that spawns them using the private execution flag. We explain how existing applications run under PRIVEXEC without modifications in Section IV-E.

ผลลัพธ์ (ไทย) 1:

A. ส่วนกระบวนการจัดการความต้องการ first สำหรับการใช้ PRIVEXEC เพื่อ เปิดใช้งานระบบปฏิบัติการที่สนับสนุนโหมดการดำเนินการส่วนตัวสำหรับกระบวนได้ ระบบปฏิบัติต้องสามารถเปิดแอพลิเคชันเป็นกระบวนการส่วนตัวตามคำขอจากผู้ใช้ สร้างเป็ก เก็บไว้ในบริบทการเข้าเกี่ยวข้องกับกระบวนการที่ การทำเครื่องหมาย และติดตามในช่วงของอายุการใช้งาน และ finally ทำลายเป็กเมื่อเธอ minates กระบวนการส่วนตัว นอกจากนี้ ความสามารถใหม่นี้ต้องไม่ตัดฟังก์ชันการจัดการกระบวนการสร้างเมล็ด พร้อมกัน ระบบปฏิบัติการที่ต้องเปิดเผยในการอินเตอร์เฟซง่ายสำหรับโปรแกรมประยุกต์ระดับผู้ใช้ร้องขอการดำเนินการส่วนตัวโดยไม่ต้อง modifications รหัสแอพลิเคชันที่มีอยู่ เคอร์เนล Linux หมายถึงกระบวนการทุกระบบใช้เป็นตัวอธิบายกระบวนการ defined เป็น struct task_struct ใน include/linux/sched.h อธิบายกระบวนการประกอบด้วยข้อมูลทั้งหมดที่จำเป็นต่อการดำเนินการ รวมทั้งฟังก์ชันเช่นการจัดการพื้นที่ที่อยู่เสมือน การจัดตารางเวลา และการบัญชี เป็นกระบวนการใหม่ เด็ก สร้างหรือ โดยการคัดลอกกระบวนการที่มีอยู่ การหลัก ทางการเรียกระบบส้อมและโคลน โคลนเป็นการเรียกระบบ Linux specific ที่มีเม็ด fine ควบคุมผ่านระบบที่ทรัพยากรหลักและรองใช้ร่วมกันผ่านชุดของแพลิดโคลนที่ส่งผ่านเป็นอาร์กิวเมนต์ และโดยปกติจะใช้สำหรับสร้างหัวข้อ ส้อม คง คงเป็นที่ตั้งของ defines โคลนแพลิดเพื่อสร้างโป cesses อิสระที่ มีความหมาย POSIX ปกติ เรียกระบบที่สองเหล่านี้ จะ เรียก do_fork ฟังก์ชันใน kernel/fork.c ที่จัดสรรอธิบายกระบวนการใหม่สำหรับเด็ก มันเริ่มต้น และเตรียมสำหรับการจัดกำหนดการ เมื่อจบกระบวนการ ตัวอย่าง โดยการออกระบบเรียก การเรียก do_exit ฟังก์ชัน ดำเนินการใน kernel/exit.c, deallocates ทรัพยากรที่เกี่ยวข้องกับกระบวนการ การใช้งานระบบของเรา เรา first ขยายตัวอธิบายกระบวนการ defining ตัวใหม่กระบวนการ flag, PF_PRIVEXECตั้งใน field สถานะของตัวอธิบายกระบวนการที่ระบุว่า เป็นกระบวนการส่วนตัว เรา defined flag ใหม่ CLONE_PRIVEXEC ที่ผ่านการโคลนเมื่อ privateprocessistobecreatedWeintroducedafieldtostore เป็กในตัวบอกเกี่ยวกับกระบวนการเรียกว่า privexec_key final นี้อธิบายกระบวนการมีมาก่อนจัดสรร struct แปลงเข้ารหัสลับที่ใช้สำหรับเข้ารหัสสลับ ที่นี่ เราอาศัยตามกรอบของเคอร์เนล Linux เข้ารหัสการเข้ารหัสลับ API); เราตามรายละเอียดของการใช้เพื่อส่วน IV-ซี การจัดการการสร้างกระบวนการส่วนตัว เรา do_fork modified เพื่อตรวจสอบสถานะของ CLONE_PRIVEXEC ในกรณี เราตั้ง PF_PRIVEXEC flag และสร้างเป็กสดที่ใช้ PRNG ที่ปลอดภัย cryptographically เป็กที่อยู่ภายในตัวบอกเกี่ยวกับกระบวนการ อยู่ในพื้นที่ที่อยู่เสมือนของเคอร์เนล และไม่เคยเปิดเผยให้กับผู้ใช้ สำหรับการหยุดชะงักของกระบวนการส่วนตัว เราปรับ do_exit เพื่อตรวจสอบสถานะของ PF_PRIVEXEC ใน bitset แพลิด ถ้ามี deallocated แปลงกระบวนการเข้ารหัสลับ และเป็กปลอดภัยจะเช็ดก่อนเพิ่มพื้นที่อธิบายกระบวนการ เนื่องจากเคอร์เนลลินุกซ์จัดการกระบวนการและกระทู้ในฟังก์ชันเดียวกัน วิธีการนี้ยังช่วยในการสร้าง และสิ้นสุดกระทู้ส่วนตัว โดยไม่มีความพยายามดำเนินการเพิ่มเติมใด ๆ โปรดสังเกตว่า โปรแกรมประยุกต์อาจวางไข่เด็กเพิ่มเติมสำหรับสร้าง subprocesses หรือกระทู้ในระหว่างการดำเนินการ นี้สามารถนำไปสู่ปัญหาสำคัญสองกับการประมวลผลหลาย และหลายเธรดทำงานภายใต้ PRIVEXEC เด็กแรก สาธารณะของกระบวนการส่วนตัวอาจทำให้เกิดการรั่วไหลความเป็นส่วนตัว เด็กสอง สาธารณะไม่สามารถเข้าถึงหลักการทางคอนเทนเนอร์ ซึ่งอาจแบ่งโปรแกรมประยุกต์ เพื่อป้องกันปัญหาเหล่านี้ ของเราแนวคิดของการดำเนินการส่วนตัวควรมีชุดเต็มของกระบวนการประยุกต์และหัวข้อ ทั้ง ๆ ที่เคอร์เนล Linux แทนพวกเขา ด้วยกระบวนการแยกตัวบอก ดังนั้น เรา do_fork modified เพื่อให้แน่ใจว่า เด็กทั้งหมดของกระบวนการส่วนตัวสืบทอดของแม่ส่วนสถานะและความเป็นส่วนตัวบริบท เป็กและคอนเทนเนอร์เก็บ ตรวจนับการอ้างอิงใช้เพื่อให้แน่ใจว่า ทรัพยากรจะถูกขายทิ้งเมื่อออกจากกลุ่มกระบวนการส่วนตัวทั้งหมด ยัง ทราบว่า งานของเราแสดง PRIVEXEC โปรแกรมประยุกต์ผู้ใช้ผ่าน flag โคลนใหม่ที่ผ่านการโคลน ดัง flag ส่วนตัวดำเนินการไม่ผ่านการเรียกร้องของระบบ ความหมายเดิมของส้อมและโคลนจะรักษา รักษาเต็มรูปแบบเข้ากันได้กับโปรแกรมประยุกต์ที่มีอยู่ ในทำนองเดียวกัน ไม่ทราบของอินเทอร์เฟซ PRIVEXEC ใหม่ดำเนินการโคลนสามารถทำส่วนตัว โดยตัด executables การกับโปรแกรมที่ spawns โดยใช้ flag การดำเนินการส่วนตัวก็ เราอธิบายวิธีที่มีอยู่โปรแกรมประยุกต์ทำงานภายใต้ PRIVEXEC ไม่ modifications ในส่วน IV-อี

ผลลัพธ์ (ไทย) 2:

A. จัดการกระบวนการเอกชนต้องการ Fi ครั้งแรกสำหรับการดำเนิน PRIVEXEC เพื่อให้ระบบปฏิบัติการที่จะสนับสนุนโหมดการดำเนินการที่เป็นส่วนตัวสำหรับกระบวนการ ระบบปฏิบัติการจะต้องสามารถเปิดโปรแกรมเป็นกระบวนการส่วนตัวเมื่อมีการร้องขอจากผู้ใช้สร้าง PEK, เก็บไว้ในบริบทสามารถเข้าถึงได้ง่ายที่เกี่ยวข้องกับกระบวนการที่ทำเครื่องหมายกระบวนการและติดตามในช่วงชีวิตของตนและ, FI Nally ทำลาย PEK เมื่อกระบวนการส่วนตัว ter- minates นอกจากนี้ความสามารถใหม่เหล่านี้จะต้องไม่ทำลายเมล็ดฟังก์ชั่นการจัดการกระบวนการที่จัดตั้งขึ้น ในเวลาเดียวกัน, OS ต้องสัมผัสอินเตอร์เฟซที่เรียบง่ายสำหรับการใช้งานระดับผู้ใช้เพื่อขอให้ดำเนินการส่วนตัวโดยไม่ต้องมีไพเพ Modi Fi โค้ดโปรแกรมที่มีอยู่ เคอร์เนลลินุกซ์แสดงให้เห็นถึงกระบวนการในระบบโดยใช้อธิบายกระบวนการที่นิยามเป็น task_struct struct ในทุก ๆ ได้แก่ ทางเข้า / Linux / sched.h อธิบายขั้นตอนการมีข้อมูลทั้งหมดที่จำเป็นในการดำเนินการขั้นตอนรวมทั้งฟังก์ชั่นเช่นการจัดตารางเวลาการบริหารจัดการพื้นที่เสมือนที่อยู่และการบัญชี กระบวนการใหม่หรือเด็กที่ถูกสร้างขึ้นโดยการคัดลอกกระบวนการที่มีอยู่หรือผู้ปกครองผ่านทางแยกและโคลนโทรระบบ โคลนเป็นลินุกซ์ speci Fi คเรียกระบบที่มีการควบคุมไฟ NE-เนื้อซึ่งทรัพยากรของระบบผู้ปกครองและเด็กร่วมกันผ่านชุดของโคลนชั้น AGS ผ่านเป็นอาร์กิวเมนต์และมักจะถูกนำมาใช้สำหรับการสร้างหัวข้อ ส้อมในมืออื่น ๆ ที่เด Fi Nes ชุดคงที่ของโคลนชั้น AGS เพื่อสร้างกระบวนการผลิตที่เป็นอิสระที่มีความหมาย POSIX ปกติ ทั้งสองระบบโทรศัพท์ในทางกลับกันเรียก do_fork ฟังก์ชั่นการใช้งานใน kernel / fork.c ซึ่งจัดสรรอธิบายกระบวนการใหม่สำหรับเด็กที่เริ่มต้นมันและเตรียมความพร้อมสำหรับการจัดตารางเวลา เมื่อกระบวนการสิ้นสุดลงเช่นโดยการอัญเชิญออกจากระบบโทร do_exit ฟังก์ชั่นการใช้งานใน kernel / exit.c ทรัพยากร deallocates เกี่ยวข้องกับกระบวนการ ที่จะใช้ระบบของเราเรา Fi ขยายแรกอธิบายกระบวนการโดย Fi หนิงกระบวนการใหม่ชั้น AG, PF_PRIVEXEC,
ที่กำหนดไว้ใน ELD ธง Fi ของอธิบายกระบวนการที่จะแสดงให้เห็นว่ามันเป็นกระบวนการที่ส่วนตัว เรานิยาม AG ชั้นใหม่ CLONE_PRIVEXEC ที่ถูกส่งไปยังโคลนเมื่อใดก็ตาม Fi privateprocessistobecreated.Weintroduceda eldtostore PEK ในการอธิบายกระบวนการที่เรียกว่า privexec_key นอกจาก Fi NAL ในการอธิบายกระบวนการที่เข้ารหัสลับการจัดสรรก่อนเปลี่ยนโครงสร้างที่ใช้สำหรับการเข้ารหัสแลกเปลี่ยน ที่นี่เราพึ่งพาอาศัยกรอบการเข้ารหัสลินุกซ์เคอร์เนลของ (Crypto API); เราเลื่อนรายละเอียดของการใช้มาตรา IV-C ที่จะจัดการกับการสร้างกระบวนการส่วนตัวเรา modi Fi เอ็ด do_fork เพื่อตรวจสอบสถานะของ CLONE_PRIVEXEC ในกรณีที่เราตั้งชั้น AG PF_PRIVEXEC และสร้าง PEK สดโดยใช้ cryptographically ปลอดภัย PRNG PEK ที่เก็บไว้ภายในอธิบายกระบวนการที่อาศัยอยู่ในพื้นที่ที่อยู่เสมือนเมล็ดและไม่เคยเปิดเผยให้กับผู้ใช้ สำหรับการยกเลิกกระบวนการส่วนตัวเราปรับ do_exit เพื่อตรวจสอบการปรากฏตัวของ PF_PRIVEXEC ในชั้น AGS bitset ถ้ามีการเข้ารหัสลับเปลี่ยนเป็น deallocated และ PEK จะถูกกำจัดอย่างปลอดภัยก่อนที่จะพ้นอธิบายกระบวนการ ตั้งแต่เคอร์เนลลินุกซ์จัดการทั้งกระบวนการและหัวข้อในการทำงานเดียวกันวิธีนี้ยังช่วยให้สำหรับการสร้างและยกเลิกกระทู้ส่วนตัวไม่มีความพยายามดำเนินการใด ๆ เพิ่มเติม โปรดทราบว่าการใช้งานอาจจะวางไข่เด็กเพิ่มเติมสำหรับการสร้างกระบวนการย่อยหรือหัวข้อในระหว่างการดำเนินการ นี้สามารถนำไปสู่สองประเด็นสำคัญที่มีหลายขั้นตอนและการใช้งานแบบมัลติเธรดทำงานภายใต้ PRIVEXEC ครั้งแรกที่เด็ก ๆ ของประชาชนในกระบวนการส่วนตัวอาจก่อให้เกิดการรั่วไหลความเป็นส่วนตัว ประการที่สองเด็กของประชาชนไม่สามารถเข้าถึงการรักษาความปลอดภัยที่เก็บของผู้ปกครองซึ่งอาจจะทำลายโปรแกรม เพื่อป้องกันไม่ให้ปัญหาเหล่านี้ความคิดของเราดำเนินการภาคเอกชนควรจะรวมถึงชุดของกระบวนการของโปรแกรมประยุกต์และกระทู้, แม้จะมีความจริงที่ว่าลินุกซ์ที่เป็นตัวแทนของพวกเขาด้วยการอธิบายกระบวนการที่แยกต่างหาก ดังนั้นเราจึง modi Fi เอ็ด do_fork เพื่อให้แน่ใจว่าเด็กทุกคนของกระบวนการส่วนตัวสืบทอดสถานะส่วนตัวของผู้ปกครองและบริบทความเป็นส่วนตัวรวมทั้ง PEK และภาชนะจัดเก็บข้อมูลที่มีความปลอดภัย นับการอ้างอิงถูกนำมาใช้เพื่อให้แน่ใจว่าทรัพยากรที่มีการกำจัดอย่างถูกต้องเมื่อทั้งหมดออกจากกระบวนการกลุ่มส่วนตัว นอกจากนี้โปรดทราบว่าการดำเนินการของเรา exposes PRIVEXEC กับการใช้งานของผู้ใช้ผ่าน AG ชั้นโคลนใหม่ที่ถูกส่งไปยังโคลน เป็นผลให้เมื่อ AG ชั้นการดำเนินส่วนตัวไม่ได้ส่งผ่านไปยังสายระบบ, ความหมายเดิมของส้อมและโคลนจะถูกเก็บไว้, การรักษาความเข้ากันได้เต็มรูปแบบกับโปรแกรมที่มีอยู่ ในทำนองเดียวกันการใช้งานที่ไม่ได้ตระหนักถึงอินเตอร์เฟซ PRIVEXEC ดำเนินการใหม่เพื่อโคลนอาจจะทำให้ภาคเอกชนโดยเพียงแค่การตัด executables ของพวกเขามีโปรแกรมที่ spawns พวกเขาโดยใช้ชั้น AG ดำเนินการส่วนตัว เราจะอธิบายวิธีการใช้งานที่มีอยู่ทำงานภายใต้ PRIVEXEC โดยไพเพอ Modi Fi ในมาตรา IV-E

ผลลัพธ์ (ไทย) 3:

การจัดการความต้องการ A จึงตัดสินใจเดินทางกระบวนการส่วนบุคคลสำหรับการใช้ privexec จะช่วยให้ระบบปฏิบัติการเพื่อสนับสนุนการดำเนินการส่วนโหมดสำหรับกระบวนการ ระบบปฏิบัติการจะต้องสามารถเปิดโปรแกรมเป็นส่วนประมวลผลเมื่อมีการร้องขอจากผู้ใช้สร้างเป็ก เก็บไว้ในบริบทที่เกี่ยวข้องกับกระบวนการที่สามารถเข้าถึงได้อย่างง่ายดาย มาร์ค กระบวนการ และติดตามมันในช่วงชีวิตของมัน และ จึงแน่นอนว่าทำลายเป็ก เมื่อกระบวนการส่วนตัวเธอ - minates . นอกจากนี้ความสามารถใหม่เหล่านี้จะต้องไม่ทำลายการสร้างกระบวนการเคอร์เนลการจัดการการทํางาน ในเวลาเดียวกัน , OS ต้องเปิดเผยอินเตอร์เฟซที่ง่ายสำหรับผู้ใช้ระดับการใช้งานเพื่อขอดำเนินการส่วนบุคคลโดยไม่ต้องสมัครงาน จึงทำให้รหัสโปรแกรมประยุกต์ที่มีอยู่Linux Kernel หมายถึงทุกกระบวนการในระบบโดยใช้กระบวนการหัวเรื่อง เดอ จึงเป็น task_struct เน็ดซอฟต์แวร์ในการรวม / Linux / นัดเรียน . . . . กระบวนการหัวเรื่องประกอบด้วยข้อมูลทั้งหมดที่จำเป็นเพื่อดำเนินการกระบวนการ รวมถึงฟังก์ชันเช่นการตั้งเวลา , เสมือนที่อยู่พื้นที่ การจัดการ การบัญชี กระบวนการใหม่ หรือ เด็ก , ถูกสร้างขึ้นโดยเลียนแบบกระบวนการที่มีอยู่ หรือพ่อแม่ผ่านระบบส้อมและสายโทร โคลนเป็น Linux จึงเรียกระบบ speci C ที่มีเนื้อละเอียด จึงไม่ควบคุม ซึ่งระบบทรัพยากรแม่และเด็กร่วมกันผ่านชุดของโคลนfl AGS ผ่านเป็นอาร์กิวเมนต์และมักจะใช้สำหรับการสร้างกระทู้ ส้อมในมืออื่น ๆ , จึงไม่ตั้งแบบคงที่ของโคลนfl AGS เพื่อสร้างอิสระโปร - cesses กับความหมาย POSIX ปกติทั้งสองระบบโทรศัพท์ จะเรียกใช้ฟังก์ชัน do_fork ใช้เคอร์เนล / ส้อม ซี ซึ่งแบ่งเป็นหัวเรื่องกระบวนการใหม่สำหรับเด็ก initializes , และเตรียมความพร้อมสำหรับการตั้งเวลา เมื่อกระบวนการสิ้นสุด ตัวอย่างเช่นโดยการออกจากระบบการเรียก ฟังก์ชัน do_exit ามาใช้ใน kernel / ออก ซี deallocates ทรัพยากรที่เกี่ยวข้องกับกระบวนการที่จะใช้ระบบของเรา เราจึงตัดสินใจเดินทางไปขยายหัวเรื่องโดยกระบวนการ de จึงหนิงกระบวนการใหม่fl AG , pf_privexec
, ที่การตั้งค่าในธงจึง ELD ของกระบวนการหัวเรื่องเพื่อบ่งชี้ว่ามันเป็นการส่วนตัว เราจึงเป็นflเน็ดใหม่โดย clone_privexec ที่ถูกโคลน เมื่อใดก็ตามที่ privateprocessistobecreated . weintroduceda จึง eldtostore ที่เป็ก ในกระบวนการการเรียก privexec_key .จึง นาล นอกจากนี้กระบวนการหัวเรื่องเป็น pre - จัดสรรแปลงซอฟต์แวร์การเข้ารหัสลับที่ใช้สำหรับการเข้ารหัสสลับ ที่นี่เราอาศัยบนลินุกซ์ เคอร์เนลของการเข้ารหัสกรอบ ( Crypto API ) ; เราเลื่อนรายละเอียดของการใช้มาตรา iv-c. เพื่อจัดการกับการสร้างกระบวนการส่วนบุคคล เราสมัครงาน จึงเอ็ด do_fork เพื่อตรวจสอบสถานะของ clone_privexec . ในกรณีที่เราตั้ง pf_privexec fl AGและสร้างเป็กสดที่ใช้ปลอดภัย cryptographically prng . ที่เป๊กจะถูกเก็บไว้ภายในกระบวนการหัวเรื่องอยู่ในเคอร์เนลเสมือนที่อยู่พื้นที่ และไม่เคยเปิดเผยให้ผู้ใช้ สำหรับการสิ้นสุดกระบวนการส่วนบุคคล เราดัดแปลง do_exit เพื่อตรวจสอบสถานะของ pf_privexec ในfl AGS bitset . ถ้าปัจจุบันกระบวนการแปลงเป็น deallocated การเข้ารหัสลับ ,และเป๊กอย่างปลอดภัยเช็ดก่อนพ้นกระบวนการหัวเรื่อง . ตั้งแต่ Linux Kernel จับทั้งกระบวนการและหัวข้อในหน้าที่เดียวกัน วิธีนี้ยังช่วยให้สำหรับการสร้างและการยกเลิกกระทู้ส่วนตัว โดยไม่มีความพยายามใด ๆเพิ่มเติม หมายเหตุโปรแกรมอาจวางไข่เด็กเพิ่มเติมเพื่อสร้าง subprocesses หรือกระทู้ในระหว่างหลักสูตรของการดำเนินการนี้สามารถนำไปสู่สองประเด็นสำคัญกับหลายกระบวนการและการใช้งานแบบมัลติเธรดทำงานภายใต้ privexec . แรกสาธารณะ เด็กของกระบวนการส่วนบุคคลอาจก่อให้เกิดการรั่วไหลของความเป็นส่วนตัว ประการที่สอง ประชาชนไม่สามารถเข้าถึงเด็กของผู้ปกครองกลายเป็นภาชนะซึ่งสามารถแบ่งโปรแกรม เพื่อป้องกันปัญหาเหล่านี้ความคิดของเราของการดำเนินการส่วนบุคคลควรมีชุดเต็มของกระบวนการและการใช้กระทู้ แม้จะมีความจริงที่ว่า Linux Kernel แทนพวกเขาด้วยในกระบวนการที่แยกต่างหาก ดังนั้น เราจึง do_fork Modi เอ็ดเพื่อให้แน่ใจว่าเด็กทุกคนของกระบวนการส่วนตัวสืบทอดผู้ปกครองสถานภาพส่วนตัวและบริบทความเป็นส่วนตัวรวมถึงทั้งเป็กและกลายเป็นภาชนะที่จัดเก็บนับอ้างอิงที่ใช้เพื่อให้แน่ใจว่าทรัพยากรถูกทำลายเมื่อกระบวนการทั้งหมดส่วนบุคคลกลุ่มออก นอกจากนี้ ทราบว่า การดำเนินงานของเราให้ privexec เพื่อการใช้งานของผู้ใช้ผ่านใหม่โคลนfl AG ที่ผ่านการโคลนนิ่ง ผล เมื่อการดำเนินการส่วนบุคคลfl AG ไม่ผ่านการเรียกระบบ ความหมายเดิมของส้อมและโคลนถูกเก็บรักษาไว้รักษาความเข้ากันได้เต็มด้วยโปรแกรมที่มีอยู่ อนึ่ง โปรแกรมประยุกต์ที่ไม่ตระหนักถึงการ privexec ใหม่อินเตอร์เฟซการโคลนอาจจะทำให้เอกชนโดยเพียงแค่ตัด executables ด้วยโปรแกรม spawns พวกเขาใช้ประหารส่วนตัวflเอจี . เราอธิบายว่า โปรแกรมที่มีอยู่ทำงานภายใต้ privexec โดย Modi จึงทำให้ในส่วน iv-e.