ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੀ ਜਾਣ-ਪਛਾਣ

ਹੇ ਹਬਰ! ਮੈਂ ਤੁਹਾਡੇ ਧਿਆਨ ਵਿੱਚ ਲੇਖਾਂ ਦੀ ਇੱਕ ਲੜੀ ਲਿਆਉਣਾ ਚਾਹਾਂਗਾ-ਮੇਰੀ ਰਾਏ ਵਿੱਚ ਇੱਕ ਦਿਲਚਸਪ ਸਾਹਿਤ ਦੇ ਅਨੁਵਾਦ - OSTEP। ਇਹ ਸਮੱਗਰੀ ਯੂਨਿਕਸ-ਵਰਗੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ ਦੇ ਕੰਮ ਦੀ ਡੂੰਘਾਈ ਨਾਲ ਚਰਚਾ ਕਰਦੀ ਹੈ, ਅਰਥਾਤ, ਪ੍ਰਕਿਰਿਆਵਾਂ, ਵੱਖ-ਵੱਖ ਸ਼ਡਿਊਲਰ, ਮੈਮੋਰੀ, ਅਤੇ ਹੋਰ ਸਮਾਨ ਭਾਗਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ ਜੋ ਇੱਕ ਆਧੁਨਿਕ OS ਬਣਾਉਂਦੇ ਹਨ। ਤੁਸੀਂ ਇੱਥੇ ਸਾਰੀਆਂ ਸਮੱਗਰੀਆਂ ਦਾ ਅਸਲੀ ਦੇਖ ਸਕਦੇ ਹੋ ਇੱਥੇ. ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਅਨੁਵਾਦ ਗੈਰ-ਪੇਸ਼ੇਵਰ ਤੌਰ 'ਤੇ ਕੀਤਾ ਗਿਆ ਸੀ (ਕਾਫ਼ੀ ਸੁਤੰਤਰ), ਪਰ ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਮੈਂ ਆਮ ਅਰਥ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਿਆ ਹੈ।

ਇਸ ਵਿਸ਼ੇ 'ਤੇ ਲੈਬ ਦਾ ਕੰਮ ਇੱਥੇ ਪਾਇਆ ਜਾ ਸਕਦਾ ਹੈ:

• ਅਸਲੀ
• ਅਸਲੀ
• ਮੇਰਾ ਨਿੱਜੀ ਅਨੁਕੂਲਨ

ਹੋਰ ਹਿੱਸੇ:

• ਭਾਗ 1: ਜਾਣ-ਪਛਾਣ
• ਭਾਗ 2: ਐਬਸਟਰੈਕਸ਼ਨ: ਪ੍ਰਕਿਰਿਆ
• ਭਾਗ 3: ਪ੍ਰਕਿਰਿਆ API ਦੀ ਜਾਣ-ਪਛਾਣ

ਤੁਸੀਂ ਮੇਰੇ ਚੈਨਲ 'ਤੇ ਵੀ ਦੇਖ ਸਕਦੇ ਹੋ ਤਾਰ =)

ਅਲਾਰਮ! ਇਸ ਲੈਕਚਰ ਲਈ ਇੱਕ ਲੈਬ ਹੈ! ਦੇਖੋ github

ਪ੍ਰਕਿਰਿਆ API

ਆਉ ਇੱਕ UNIX ਸਿਸਟਮ ਵਿੱਚ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਬਣਾਉਣ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਵੇਖੀਏ। ਇਹ ਦੋ ਸਿਸਟਮ ਕਾਲਾਂ ਰਾਹੀਂ ਹੁੰਦਾ ਹੈ ਕਾਂਟਾ () и exec().

ਕਾਲ ਫੋਰਕ()

ਇੱਕ ਪ੍ਰੋਗਰਾਮ 'ਤੇ ਵਿਚਾਰ ਕਰੋ ਜੋ ਫੋਰਕ() ਕਾਲ ਕਰਦਾ ਹੈ। ਇਸ ਦੇ ਲਾਗੂ ਹੋਣ ਦਾ ਨਤੀਜਾ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਹੋਵੇਗਾ।

ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਅਸੀਂ main() ਫੰਕਸ਼ਨ ਦਾਖਲ ਕਰਦੇ ਹਾਂ ਅਤੇ ਸਟ੍ਰਿੰਗ ਨੂੰ ਸਕ੍ਰੀਨ ਤੇ ਪ੍ਰਿੰਟ ਕਰਦੇ ਹਾਂ। ਲਾਈਨ ਵਿੱਚ ਪ੍ਰਕਿਰਿਆ ਪਛਾਣਕਰਤਾ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ ਜਿਸ ਨੂੰ ਅਸਲ ਵਿੱਚ ਕਿਹਾ ਜਾਂਦਾ ਹੈ PID ਜਾਂ ਪ੍ਰਕਿਰਿਆ ਪਛਾਣਕਰਤਾ। ਇਹ ਪਛਾਣਕਰਤਾ UNIX ਵਿੱਚ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਦਾ ਹਵਾਲਾ ਦੇਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਅਗਲੀ ਕਮਾਂਡ ਫੋਰਕ () ਨੂੰ ਕਾਲ ਕਰੇਗੀ। ਇਸ ਮੌਕੇ 'ਤੇ, ਪ੍ਰਕਿਰਿਆ ਦੀ ਲਗਭਗ ਸਹੀ ਕਾਪੀ ਬਣਾਈ ਜਾਂਦੀ ਹੈ. OS ਲਈ, ਅਜਿਹਾ ਲਗਦਾ ਹੈ ਕਿ ਸਿਸਟਮ 'ਤੇ ਇੱਕੋ ਪ੍ਰੋਗਰਾਮ ਦੀਆਂ 2 ਕਾਪੀਆਂ ਚੱਲ ਰਹੀਆਂ ਹਨ, ਜੋ ਬਦਲੇ ਵਿੱਚ ਫੋਰਕ() ਫੰਕਸ਼ਨ ਤੋਂ ਬਾਹਰ ਆ ਜਾਣਗੀਆਂ। ਮੁੱਖ() ਫੰਕਸ਼ਨ ਤੋਂ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋਏ, ਨਵੀਂ ਬਣਾਈ ਗਈ ਚਾਈਲਡ ਪ੍ਰਕਿਰਿਆ (ਪੈਰੈਂਟ ਪ੍ਰਕਿਰਿਆ ਦੇ ਸਬੰਧ ਵਿੱਚ ਜਿਸ ਨੇ ਇਸਨੂੰ ਬਣਾਇਆ ਹੈ) ਨੂੰ ਲਾਗੂ ਨਹੀਂ ਕੀਤਾ ਜਾਵੇਗਾ। ਇਹ ਯਾਦ ਰੱਖਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਇੱਕ ਬਾਲ ਪ੍ਰਕਿਰਿਆ ਮਾਤਾ-ਪਿਤਾ ਪ੍ਰਕਿਰਿਆ ਦੀ ਇੱਕ ਸਹੀ ਕਾਪੀ ਨਹੀਂ ਹੈ; ਖਾਸ ਤੌਰ 'ਤੇ, ਇਸਦਾ ਆਪਣਾ ਪਤਾ ਸਪੇਸ, ਇਸਦੇ ਆਪਣੇ ਰਜਿਸਟਰ, ਚੱਲਣਯੋਗ ਨਿਰਦੇਸ਼ਾਂ ਲਈ ਇਸਦਾ ਆਪਣਾ ਪੁਆਇੰਟਰ, ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਹੋਰ ਹਨ। ਇਸ ਤਰ੍ਹਾਂ, ਫੋਰਕ() ਫੰਕਸ਼ਨ ਦੇ ਕਾਲਰ ਨੂੰ ਵਾਪਸ ਕੀਤਾ ਗਿਆ ਮੁੱਲ ਵੱਖਰਾ ਹੋਵੇਗਾ। ਖਾਸ ਤੌਰ 'ਤੇ, ਮਾਤਾ-ਪਿਤਾ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਵਾਪਸੀ ਦੇ ਰੂਪ ਵਿੱਚ ਬੱਚੇ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦਾ PID ਮੁੱਲ ਪ੍ਰਾਪਤ ਹੋਵੇਗਾ, ਅਤੇ ਬੱਚੇ ਨੂੰ 0 ਦੇ ਬਰਾਬਰ ਮੁੱਲ ਪ੍ਰਾਪਤ ਹੋਵੇਗਾ। ਇਹਨਾਂ ਵਾਪਸੀ ਕੋਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਤੁਸੀਂ ਫਿਰ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਵੱਖ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਉਹਨਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਨੂੰ ਆਪਣਾ ਕੰਮ ਕਰਨ ਲਈ ਮਜਬੂਰ ਕਰ ਸਕਦੇ ਹੋ। . ਹਾਲਾਂਕਿ, ਇਸ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਲਾਗੂ ਕਰਨ ਨੂੰ ਸਖਤੀ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ। 2 ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿੱਚ ਵੰਡਣ ਤੋਂ ਬਾਅਦ, OS ਉਹਨਾਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਨਾਲ ਹੀ ਉਹਨਾਂ ਦੇ ਕੰਮ ਦੀ ਯੋਜਨਾ ਬਣਾਉਂਦਾ ਹੈ. ਜੇਕਰ ਸਿੰਗਲ-ਕੋਰ ਪ੍ਰੋਸੈਸਰ 'ਤੇ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿੱਚੋਂ ਇੱਕ, ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਮਾਤਾ-ਪਿਤਾ ਕੰਮ ਕਰਨਾ ਜਾਰੀ ਰੱਖੇਗਾ, ਅਤੇ ਫਿਰ ਬਾਲ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਨਿਯੰਤਰਣ ਪ੍ਰਾਪਤ ਹੋਵੇਗਾ। ਮੁੜ-ਚਾਲੂ ਕਰਨ ਵੇਲੇ, ਸਥਿਤੀ ਵੱਖਰੀ ਹੋ ਸਕਦੀ ਹੈ।

ਕਾਲ ਉਡੀਕ ()

ਹੇਠਾਂ ਦਿੱਤੇ ਪ੍ਰੋਗਰਾਮ 'ਤੇ ਗੌਰ ਕਰੋ। ਇਸ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਕਾਲ ਦੀ ਮੌਜੂਦਗੀ ਕਾਰਨ ਸ ਉਡੀਕ ਕਰੋ() ਮਾਤਾ-ਪਿਤਾ ਦੀ ਪ੍ਰਕਿਰਿਆ ਹਮੇਸ਼ਾ ਬੱਚੇ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦੇ ਪੂਰਾ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰੇਗੀ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਸਾਨੂੰ ਸਕ੍ਰੀਨ 'ਤੇ ਇੱਕ ਸਖਤੀ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਟੈਕਸਟ ਆਉਟਪੁੱਟ ਮਿਲੇਗਾ

exec() ਕਾਲ ਕਰੋ

ਚੁਣੌਤੀ 'ਤੇ ਗੌਰ ਕਰੋ exec(). ਇਹ ਸਿਸਟਮ ਕਾਲ ਲਾਭਦਾਇਕ ਹੈ ਜਦੋਂ ਅਸੀਂ ਇੱਕ ਬਿਲਕੁਲ ਵੱਖਰਾ ਪ੍ਰੋਗਰਾਮ ਚਲਾਉਣਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਇੱਥੇ ਅਸੀਂ ਕਾਲ ਕਰਾਂਗੇ execvp() wc ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਚਲਾਉਣ ਲਈ ਜੋ ਕਿ ਇੱਕ ਸ਼ਬਦ ਗਿਣਤੀ ਪ੍ਰੋਗਰਾਮ ਹੈ। ਜਦੋਂ exec() ਨੂੰ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਕੀ ਹੁੰਦਾ ਹੈ? ਇਸ ਕਾਲ ਨੂੰ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਫਾਈਲ ਦਾ ਨਾਮ ਅਤੇ ਆਰਗੂਮੈਂਟ ਦੇ ਤੌਰ 'ਤੇ ਕੁਝ ਪੈਰਾਮੀਟਰ ਪਾਸ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਜਿਸ ਤੋਂ ਬਾਅਦ ਇਸ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਫਾਈਲ ਤੋਂ ਕੋਡ ਅਤੇ ਸਟੈਟਿਕ ਡੇਟਾ ਲੋਡ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਕੋਡ ਦੇ ਨਾਲ ਇਸਦੇ ਆਪਣੇ ਹਿੱਸੇ ਨੂੰ ਓਵਰਰਾਈਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਬਾਕੀ ਬਚੇ ਮੈਮੋਰੀ ਖੇਤਰ, ਜਿਵੇਂ ਕਿ ਸਟੈਕ ਅਤੇ ਹੀਪ, ਮੁੜ-ਸ਼ੁਰੂ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਜਿਸ ਤੋਂ ਬਾਅਦ OS ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਐਗਜ਼ੀਕਿਊਟ ਕਰਦਾ ਹੈ, ਇਸ ਨੂੰ ਆਰਗੂਮੈਂਟਸ ਦਾ ਇੱਕ ਸੈੱਟ ਪਾਸ ਕਰਦਾ ਹੈ। ਇਸ ਲਈ ਅਸੀਂ ਕੋਈ ਨਵੀਂ ਪ੍ਰਕਿਰਿਆ ਨਹੀਂ ਬਣਾਈ, ਅਸੀਂ ਮੌਜੂਦਾ ਚੱਲ ਰਹੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਇੱਕ ਹੋਰ ਚੱਲ ਰਹੇ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਬਦਲ ਦਿੱਤਾ ਹੈ। ਵੰਸ਼ ਵਿੱਚ exec() ਕਾਲ ਨੂੰ ਚਲਾਉਣ ਤੋਂ ਬਾਅਦ, ਅਜਿਹਾ ਲਗਦਾ ਹੈ ਕਿ ਅਸਲ ਪ੍ਰੋਗਰਾਮ ਬਿਲਕੁਲ ਨਹੀਂ ਚੱਲਿਆ।

ਇਹ ਸ਼ੁਰੂਆਤੀ ਪੇਚੀਦਗੀ ਯੂਨਿਕਸ ਸ਼ੈੱਲ ਲਈ ਪੂਰੀ ਤਰ੍ਹਾਂ ਆਮ ਹੈ, ਅਤੇ ਉਸ ਸ਼ੈੱਲ ਨੂੰ ਕਾਲ ਕਰਨ ਤੋਂ ਬਾਅਦ ਕੋਡ ਨੂੰ ਚਲਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ ਕਾਂਟਾ (), ਪਰ ਕਾਲ ਤੋਂ ਪਹਿਲਾਂ exec(). ਅਜਿਹੇ ਕੋਡ ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਸ਼ੈੱਲ ਵਾਤਾਵਰਨ ਨੂੰ ਲਾਂਚ ਕੀਤੇ ਜਾ ਰਹੇ ਪ੍ਰੋਗਰਾਮ ਦੀਆਂ ਲੋੜਾਂ ਮੁਤਾਬਕ ਐਡਜਸਟ ਕਰਨਾ, ਇਸਨੂੰ ਲਾਂਚ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ।

ਸ਼ੈਲ - ਸਿਰਫ਼ ਇੱਕ ਉਪਭੋਗਤਾ ਪ੍ਰੋਗਰਾਮ. ਉਹ ਤੁਹਾਨੂੰ ਸੱਦਾ ਪੱਤਰ ਦਿਖਾਉਂਦੀ ਹੈ ਅਤੇ ਇਸ ਵਿੱਚ ਤੁਹਾਡੇ ਕੁਝ ਲਿਖਣ ਦੀ ਉਡੀਕ ਕਰਦੀ ਹੈ। ਜ਼ਿਆਦਾਤਰ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਜੇਕਰ ਤੁਸੀਂ ਉੱਥੇ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਦਾ ਨਾਮ ਲਿਖਦੇ ਹੋ, ਤਾਂ ਸ਼ੈੱਲ ਇਸਦਾ ਸਥਾਨ ਲੱਭੇਗਾ, ਫੋਰਕ() ਵਿਧੀ ਨੂੰ ਕਾਲ ਕਰੇਗਾ, ਅਤੇ ਫਿਰ ਇੱਕ ਨਵੀਂ ਪ੍ਰਕਿਰਿਆ ਬਣਾਉਣ ਲਈ ਕਿਸੇ ਕਿਸਮ ਦੇ exec() ਨੂੰ ਕਾਲ ਕਰੋ ਅਤੇ ਇੱਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸਦੇ ਪੂਰਾ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰੋ। wait() ਕਾਲ ਕਰੋ। ਜਦੋਂ ਚਾਈਲਡ ਪ੍ਰਕਿਰਿਆ ਬੰਦ ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਸ਼ੈੱਲ wait() ਕਾਲ ਤੋਂ ਵਾਪਸ ਆ ਜਾਵੇਗਾ ਅਤੇ ਪ੍ਰੋਂਪਟ ਨੂੰ ਦੁਬਾਰਾ ਪ੍ਰਿੰਟ ਕਰੇਗਾ ਅਤੇ ਅਗਲੀ ਕਮਾਂਡ ਦੇ ਦਾਖਲ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰੇਗਾ।

ਫੋਰਕ() ਅਤੇ exec() ਸਪਲਿਟ ਸ਼ੈੱਲ ਨੂੰ ਹੇਠ ਲਿਖੀਆਂ ਚੀਜ਼ਾਂ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ:
wc ਫਾਈਲ> ਨਵੀਂ_ਫਾਈਲ.

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, wc ਪ੍ਰੋਗਰਾਮ ਦੇ ਆਉਟਪੁੱਟ ਨੂੰ ਇੱਕ ਫਾਈਲ ਵਿੱਚ ਰੀਡਾਇਰੈਕਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਸ਼ੈੱਲ ਦੁਆਰਾ ਇਸ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਦਾ ਤਰੀਕਾ ਕਾਫ਼ੀ ਸਰਲ ਹੈ - ਕਾਲ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ ਚਾਈਲਡ ਪ੍ਰਕਿਰਿਆ ਬਣਾ ਕੇ exec(), ਸ਼ੈੱਲ ਸਟੈਂਡਰਡ ਆਉਟਪੁੱਟ ਬੰਦ ਕਰਦਾ ਹੈ ਅਤੇ ਫਾਈਲ ਨੂੰ ਖੋਲ੍ਹਦਾ ਹੈ new_file, ਇਸ ਤਰ੍ਹਾਂ, ਅੱਗੇ ਚੱਲ ਰਹੇ ਪ੍ਰੋਗਰਾਮ ਤੋਂ ਸਾਰਾ ਆਉਟਪੁੱਟ wc ਇੱਕ ਸਕਰੀਨ ਦੀ ਬਜਾਏ ਇੱਕ ਫਾਇਲ 'ਤੇ ਰੀਡਾਇਰੈਕਟ ਕੀਤਾ ਜਾਵੇਗਾ.

ਯੂਨਿਕਸ ਪਾਈਪ ਇਸੇ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਇਸ ਅੰਤਰ ਨਾਲ ਕਿ ਉਹ ਪਾਈਪ() ਕਾਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਪ੍ਰਕਿਰਿਆ ਦੀ ਆਉਟਪੁੱਟ ਸਟ੍ਰੀਮ ਕਰਨਲ ਵਿੱਚ ਸਥਿਤ ਪਾਈਪ ਕਤਾਰ ਨਾਲ ਜੁੜੀ ਹੋਵੇਗੀ, ਜਿਸ ਨਾਲ ਕਿਸੇ ਹੋਰ ਪ੍ਰਕਿਰਿਆ ਦੀ ਇਨਪੁਟ ਸਟ੍ਰੀਮ ਜੁੜ ਜਾਵੇਗੀ।

ਸਰੋਤ: www.habr.com