ਲੀਨਕਸ ਤੇ ਟੈਕਸਟ-ਟਰਮੀਨਲ

14.1 ਗੈਟਟੀ (/ etc / inittab ਵਿੱਚ ਵਰਤੀ ਗਈ)

ਗੈਟਟੀ ਨਾਲ ਜਾਣ ਪਛਾਣ

ਇੱਕ ਸੀਰੀਅਲ ਪੋਰਟ (ਅਤੇ ਇਸ ਨਾਲ ਜੁੜੇ ਟਰਮੀਨਲ) ਤੇ ਇੱਕ ਲਾਗਇਨ ਪ੍ਰਕਿਰਿਆ ਚਲਾਉਣ ਲਈ, ਜਦੋਂ ਕੰਪਿਊਟਰ ਦੀ ਚਾਲੂ ਹੁੰਦੀ ਹੈ (ਜਾਂ ਰਨ ਲੈਵਲ ਚਲਾਉਂਦਾ ਹੈ) ਇੱਕ getty ਕਮਾਂਡ ਨੂੰ / etc / inittab ਫਾਇਲ ਵਿੱਚ ਲਾਜ਼ਮੀ ਤੌਰ ਤੇ ਰੱਖਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ. ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ Getty ਜਾ ਰਹੀ ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਕਰ ਸਕਦੀਆਂ ਹਨ (ਵੇਖੋ ਜੇ getty ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ ਚਲਦੀ ਹੈ: ਪ੍ਰੋਗਰਾਮ ਦੇਖਣ ਲਈ ਕਿਉਂ ਰੋਕਿਆ ਗਿਆ ਹੈ). Getty ਇੱਕ TTY (ਇੱਕ ਟਰਮੀਨਲ) ਨੂੰ ਜਾ ਰਿਹਾ ਹੈ ਹਰੇਕ ਟਰਮੀਨਲ ਨੂੰ ਆਪਣੀ ਗਤਿਸੀ ਕਮਾਂਡ ਦੀ ਜਰੂਰਤ ਹੈ. ਹਰੇਕ / etc / inittab ਫਾਇਲ ਵਿੱਚ ਕਨਸੋਲ ਲਈ ਘੱਟੋ-ਘੱਟ ਇੱਕ getty ਕਮਾਂਡ ਵੀ ਹੈ. ਇਹ ਲੱਭੋ ਅਤੇ getty ਕਮਾਂਡਾਂ ਨੂੰ ਇਸ ਤੋਂ ਅੱਗੇ ਦੇ ਅਸਲੀ ਟਰਮੀਨਲਾਂ ਲਈ ਪਾਓ. ਇਸ ਫਾਇਲ ਵਿੱਚ ਟੈਕਸਟ ਟਰਮੀਨਲ ਲਈ ਨਮੂਨੇ ਮਿਲਟੀ ਲਾਈਨਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ ਜਿਹੜੀਆਂ ਟਿੱਪਣੀ ਕੀਤੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ ਤਾਂ ਜੋ ਤੁਹਾਨੂੰ ਜੋ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਉਹ ਉਹਨਾਂ ਨੂੰ ਅਨੁਕ੍ਰਮ ਕਰਨ (ਪ੍ਰਮੁੱਖ # ਨੂੰ ਹਟਾਉ) ਅਤੇ ਕੁਝ ਆਰਗੂਮਿੰਟ ਬਦਲਣ.

ਜਿਨ੍ਹਾਂ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਆਗਿਆ ਹੈ, ਉਨ੍ਹਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ ਕਿ ਤੁਸੀਂ ਕਿਸ ਗੈਟਟੀ ਨੂੰ ਵਰਤਦੇ ਹੋ:
ਸਿੱਧੇ ਜੁੜੇ ਟਰਮੀਨਲਾਂ ਲਈ ਬਿਹਤਰ ਦੋ gettys ਹਨ:

• ਐਗੇਟਿਟੀ (ਕਈ ਵਾਰ ਸਿਰਫ Getty ਕਿਹਾ ਜਾਂਦਾ ਹੈ): ਸੈੱਟਅੱਪ ਕਰਨਾ ਬਹੁਤ ਸੌਖਾ ਹੈ. ਕੋਈ ਸੰਰਚਨਾ ਫਾਇਲਾਂ ਨਹੀਂ. ਐਂਜੀਟਾ ਵੇਖੋ
• getty (getty_ps ਦਾ ਹਿੱਸਾ)

ਡਾਇਲ-ਇਨ ਮਾਡਮਜ਼ (ਸਿੱਧਾ ਜੁੜੇ ਹੋਏ ਟਰਮੀਨਲਾਂ ਲਈ ਟਾਲਣਾ) ਲਈ ਬਿਹਤਰ ਦੋ gettys ਹਨ:

• mgetty: ਮਾਡਮਾਂ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਇੱਕ; ਟਰਮੀਨਲ ਲਈ ਬਹੁਤ ਕੰਮ ਕਰਦਾ ਹੈ ਪਰ ਘਟੀਆ
• uugetty: ਸਿਰਫ ਮਾਡਮ ਲਈ; getty_ps ਪੈਕੇਜ ਦਾ ਹਿੱਸਾ

ਜੇ ਤੁਸੀਂ ਅਸਲੀ ਟੈਕਸਟ-ਟਰਮੀਨਲ ਨਹੀਂ ਵਰਤਦੇ ਤਾਂ ਵਰਤਣ ਲਈ ਸਧਾਰਨ Gettys ਜ਼ਿਆਦਾਤਰ ਲੀਨਕਸ ਉਪਭੋਗਤਾ ਆਪਣੇ ਮਾਨੀਟਰ ਤੇ ਇਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ:

• mingetty
• fbgetty
• fgetty
• ਰਨਗਲਟੀ

ਤੁਹਾਡਾ ਲੀਨਕਸ ਵੰਡ ਪਾਠ-ਟਰਮੀਨਲਾਂ ਲਈ ਜਾਂ ਤਾਂ ps_getty ਜਾਂ agetty ਦੇ ਨਾਲ ਆ ਸਕਦੀ ਹੈ. ਕੁਝ ਡਿਸਟਰੀਬਿਊਸ਼ਨ ਨਾ ਤਾਂ ਸਪਲਾਈ ਕਰਦੀਆਂ ਹਨ. ਬਦਕਿਸਮਤੀ ਨਾਲ, ਉਹ ਅਕਸਰ ਇਸ ਨੂੰ "getty" ਕਹਿੰਦੇ ਹਨ, ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਇਹ ਪਤਾ ਕਰਨ ਦੀ ਲੋੜ ਪੈ ਸਕਦੀ ਹੈ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਕਿਹੜਾ ਹੈ ਜਦੋਂ ਤੋਂ ਬਾਅਦ ਵਿੱਚ ਆਰਗੂਮੈਂਟ ਤੁਸੀਂ / etc / inittab ਵਿੱਚ ਵੱਖਰੇ ਹੋ. ਡੇਬੀਅਨ ਐਗਰਿਟਟੀ (ਯੂ ਪੀ-ਲਿਨਕਸ ਪੈਕੇਜ ਵਿੱਚ) ਵਰਤਦਾ ਹੈ. RedHat ਅਤੇ ਫੇਡੋਰਾ ਨੇ ps_getty ਦਾ ਇਸਤੇਮਾਲ ਕੀਤਾ ਹੈ: ps_getty

ਇਹ ਪਤਾ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਲਈ ਆਖ਼ਰੀ ਉਪਾਅ ਹੋਣ ਦੇ ਤੌਰ ਤੇ ਤੁਸੀਂ ਆਪਣੇ ਐਕਟੀਵੇਟਿਡ ਕੋਡ (ਆਮ ਤੌਰ ਤੇ / sbin) ਨੂੰ ਵੇਖ ਸਕਦੇ ਹੋ. ps_getty ਵਿੱਚ ਇਸ ਕੋਡ ਵਿੱਚ ਸ਼ਾਮਿਲ / etc / gettydefs ਹੈ. ਇਸ ਦੀ ਖੋਜ ਕਰਨ ਲਈ, / sbin ਤੇ ਜਾਓ ਅਤੇ ਟਾਈਪ ਕਰੋ:
ਸਤਰ | grep getty
ਜੇ Getty ਅਸਲ ਵਿੱਚ ਐਗੇਟ੍ਰੀ ਹੈ ਤਾਂ ਉਪਰੋਕਤ ਦੇ ਨਤੀਜੇ ਵਿੱਚ ਕੁਝ ਨਹੀਂ ਹੋਵੇਗਾ ਹਾਲਾਂਕਿ ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਐਂੱਗੇਟੀ ਟਾਈਪਿੰਗ ਹੈ:
Getty -h
ਚੋਣਾਂ ਦਰਸਾਉਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ [-ਐਮ ਐਮ ਐਮ ਐੱਮ]

ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਗੈਸਟਟੀ ਨਹੀਂ ਹੈ ਤਾਂ ਤੁਸੀਂ ਹੋਰ ਡਿਸਟਰੀਬਿਊਸ਼ਨ ਵੇਖਣਾ ਚਾਹੁੰਦੇ ਹੋ ਅਤੇ RPM ਅਤੇ Debian ਪੈਕੇਜਾਂ ਵਿੱਚ ਤਬਦੀਲ ਕਰਨ ਲਈ ਪਰਦੇਸੀ ਪ੍ਰੋਗਰਾਮ ਵੇਖਣਾ ਚਾਹੁੰਦੇ ਹੋ. ਸਰੋਤ ਕੋਡ ਨੂੰ ਗੈਟਟੀ ਸੌਫਟਵੇਅਰ ਤੋਂ ਡਾਊਨਲੋਡ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ.

ਜੇ ਤੁਸੀਂ ਮਾਡਮ ਕੰਟਰੋਲ ਲਾਈਨਾਂ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰ ਰਹੇ ਹੋ (ਉਦਾਹਰਣ ਵਜੋਂ ਜੇ ਤੁਸੀਂ ਘੱਟੋ ਘੱਟ 3 ਕੰਡਕਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ: ਪ੍ਰਸਾਰਿਤ ਕਰੋ, ਪ੍ਰਾਪਤ ਕਰੋ, ਅਤੇ ਆਮ ਸਿਗਨਲ ਮੈਗਡੰਡਲ) ਤਾਂ ਤੁਹਾਨੂੰ "ਸਥਾਨਕ" ਫਲੈਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸ ਨੂੰ ਜਾਨਣਾ ਚਾਹੀਦਾ ਹੈ. ਇਸਦਾ ਫ਼ਾਰਮ ਇਹ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਕਿਸ ਗੈਟਟੀ ਨੂੰ ਤੁਸੀਂ ਵਰਤਦੇ ਹੋ.

ਗੈਟਟੀ ਲਾਗਇਨ ਤੋਂ ਬਾਅਦ ਨਿਕਲਦੀ ਹੈ (ਅਤੇ ਹੋ ਸਕਦਾ ਹੈ respawn)

ਤੁਹਾਡੇ ਲਾਗਿੰਨ ਕਰਨ ਤੋਂ ਬਾਅਦ ਤੁਸੀਂ ਵੇਖੋਗੇ ("ਸਿਖਰ", "ps -ax", ਜਾਂ "ptree" ਵਰਤ ਕੇ) ਜੋ ਕਿ ਗੈਟਟੀ ਪ੍ਰਕਿਰਿਆ ਹੁਣ ਚੱਲ ਰਹੀ ਹੈ. ਇਸ ਨੂੰ ਕੀ ਹੋਇਆ? ਜੇ ਤੁਹਾਡਾ ਸ਼ੈਲ ਮਾਰਿਆ ਗਿਆ ਹੈ ਤਾਂ ਗੈਟਟੀ ਦੁਬਾਰਾ ਚਾਲੂ ਕਿਉਂ ਹੁੰਦੀ ਹੈ? ਇੱਥੇ ਕਿਉਂ ਹੈ?

ਤੁਹਾਡੇ ਉਪਭੋਗਤਾ ਨਾਮ ਵਿੱਚ ਟਾਈਪ ਕਰਨ ਤੋਂ ਬਾਅਦ, Getty ਇਸ ਨੂੰ ਲੈਂਦਾ ਹੈ ਅਤੇ ਲੌਗਇਨ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ ਜੋ ਇਸਨੂੰ ਤੁਹਾਡੇ ਉਪਭੋਗਤਾ ਨਾਮ ਦੱਸ ਰਿਹਾ ਹੈ. Getty ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਲਾਗਇਨ ਪ੍ਰਕਿਰਿਆ ਦੁਆਰਾ ਬਦਲ ਦਿੱਤਾ ਗਿਆ ਹੈ. ਲਾਗਇਨ ਪ੍ਰਕਿਰਿਆ ਤੁਹਾਡੇ ਪਾਸਵਰਡ ਲਈ ਪੁੱਛਦੀ ਹੈ, ਇਸ ਦੀ ਜਾਂਚ ਕਰਦੀ ਹੈ ਅਤੇ ਜੋ ਵੀ ਤੁਹਾਡੀ ਪ੍ਰਾਸੈਸ ਫਾਇਲ ਵਿੱਚ ਦਰਸਾਈ ਜਾਂਦੀ ਹੈ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ. ਇਹ ਪ੍ਰਕ੍ਰਿਆ ਆਮ ਤੌਰ ਤੇ bash ਸ਼ੈੱਲ ਹੁੰਦੀ ਹੈ. ਜੇ ਅਜਿਹਾ ਹੈ, ਤਾਂ ਬੈਸ਼ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ ਅਤੇ ਲਾਗਇਨ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਬਦਲ ਦਿੰਦਾ ਹੈ. ਨੋਟ ਕਰੋ ਕਿ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਦੂਜੀ ਦੀ ਥਾਂ ਤੇ ਹੈ ਅਤੇ ਕਿ bash ਸ਼ੈੱਲ ਪ੍ਰਕਿਰਿਆ ਅਸਲ ਵਿੱਚ Getty ਪ੍ਰਕਿਰਿਆ ਦੇ ਰੂਪ ਵਿੱਚ ਸ਼ੁਰੂ ਕੀਤੀ ਗਈ ਹੈ. ਇਸ ਦੇ ਸਿੱਟੇ ਹੇਠਾਂ ਵਿਆਖਿਆ ਕੀਤੀ ਜਾਵੇਗੀ.

ਹੁਣ / etc / inittab ਫਾਇਲ ਵਿੱਚ, Getty ਨੂੰ ਮਾਰਿਆ ਜਾਵੇਗਾ ਜੇ ਮੁੜ ਕੇ ਮੁੜ ਚਾਲੂ ਕਰੋ (ਮਾਰੋ) ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਕਹਿੰਦਾ ਹੈ ਕਿ ਪ੍ਰਾਪਤ ਲਾਈਨ ਪਰ ਜੇ bash ਸ਼ੈੱਲ (ਜਾਂ ਲਾਗਇਨ ਪ੍ਰਕਿਰਿਆ) ਖਤਮ ਹੋ ਜਾਂਦੀ ਹੈ, Getty respawns (ਮੁੜ ਸ਼ੁਰੂ). ਕਿਉਂ? Well, ਲੌਗਿਨ ਪ੍ਰਕਿਰਿਆ ਅਤੇ bash ਦੋਵੇਂ ਗਤਿਸੀ ਦੇ ਬਦਲੇ ਹਨ ਅਤੇ ਵਾਰਸ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਨ

* ਟੈਕਸਟ ਟਰਮੀਨਲ ਕਿਸ-ਟੂ ਇੰਡੈਕਸ

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

ਜਦੋਂ ਇੱਕ ਲੌਗ ਆ ਜਾਂਦਾ ਹੈ, ਉਸ ਸੀਰੀਅਲ ਪੋਰਟ ਤੇ ਸਾਰੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਮਾਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ bash shell ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ. ਇਹ ਵੀ ਹੋ ਸਕਦਾ ਹੈ (ਜੇ ਸਮਰਥਿਤ ਹੋਵੇ) ਜੇਕਰ ਹੈਂਡਪ ਸੰਕੇਤ ਮਾਡਮ ਦੁਆਰਾ ਡੀਸੀਡੀ ਵੋਲਟੇਜ ਦੀ ਇੱਕ ਬੂੰਦ ਨਾਲ ਸੀਰੀਅਲ ਪੋਰਟ ਤੇ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ. ਜਾਂ ਤਾਂ ਡੀ.ਡੀ.ਡੀ. ਦੇ ਘੁੰਮਣ-ਆਊਟ ਜਾਂ ਡਰਾਪ ਦਾ ਨਤੀਜਾ ਗੜਬੜ-ਭੜਕਣ ਦਾ ਨਤੀਜਾ ਹੋਵੇਗਾ. ਕੋਈ ਵੀ Getty ਨੂੰ k ਕੁੰਜੀ, ਆਦਿ ਨੂੰ ਮਾਰ ਕੇ ਖੁਦ ਮਾਰ ਕੇ ਮਾਰ ਕੇ (ਜਾਂ ਲੌਗਿਨ ਰਾਹੀਂ) ਸਾਹ ਲੈਂਦਾ ਹੈ ਜਦੋਂ ਕਿ "ਸਿਖਰ" ਵਿਚ ਹੈ ਜਾਂ "kill" ਕਮਾਂਡ ਨਾਲ. ਤੁਹਾਨੂੰ ਸੰਭਾਵਤ ਸਿਗਨਲ 9 ਨਾਲ ਇਸਨੂੰ ਮਾਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ (ਜਿਸ ਨੂੰ ਅਣਡਿੱਠਾ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ)

ਜੇ Getty ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ ਚਲਦੀ ਹੈ: ਪ੍ਰੋਗਰਾਮ ਬੰਦ ਹੋ ਜਾਂਦੇ ਹਨ

ਤੁਹਾਨੂੰ ਆਮ ਤੌਰ 'ਤੇ / etc / inittab ਦੇ ਅੰਦਰੋਂ getty ਚਲਾਉਣਾ ਚਾਹੀਦਾ ਹੈ ਨਾ ਕਿ ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ ਜਾਂ ਫਿਰ ਟਰਮੀਨਲ ਤੇ ਚੱਲ ਰਹੇ ਕੁਝ ਪਰੋਗਰਾਮ ਅਚਾਨਕ ਮੁਅੱਤਲ (ਰੁਕੇ) ਹੋ ਸਕਦੇ ਹਨ. ਇੱਥੇ ਕਿਉਂ ਹੈ (ਜੇ ਤੁਹਾਡੇ ਲਈ ਮਹੱਤਵਪੂਰਨ ਨਹੀਂ ਹੈ ਤਾਂ ਅਗਲੇ ਸੈਕਸ਼ਨ ਤੇ ਜਾਉ). ਜੇ ਤੁਸੀਂ ਕਿਸੇ ਹੋਰ ਟਰਮੀਨਲ ਦੇ ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ ttyS1 ਕਹਿੰਦੇ ਹੋ, ਤਾਂ tty1 ਲਿਖੋ, ਫਿਰ ਇਸ ਵਿੱਚ "ਕੰਟਰੋਲਿੰਗ ਟਰਮੀਨਲ" ਦੇ ਤੌਰ ਤੇ tty1 ਹੋਵੇਗਾ ਭਾਵੇਂ ਕਿ ਅਸਲ ਟਰਮੀਨਲ ਤੇ ਚੱਲ ਰਿਹਾ ਹੈ ttyS1. ਇਸ ਲਈ ਇਸ ਵਿੱਚ ਗਲਤ ਨਿਯੰਤ੍ਰਣ ਟਰਮੀਨਲ ਹੈ. ਪਰ ਜੇ ਇਹ ਇਨਟੈਬ ਫਾਇਲ ਦੇ ਅੰਦਰ ਸ਼ੁਰੂ ਹੋ ਜਾਵੇ ਤਾਂ ਇਸ ਵਿੱਚ ttyS1 ਨੂੰ ਕੰਟਰੋਲਿੰਗ ਟਰਮੀਨਲ (ਸਹੀ) ਦੇ ਤੌਰ ਤੇ ਰੱਖਿਆ ਜਾਵੇਗਾ.

ਭਾਵੇਂ ਕੰਟਰੋਲਿੰਗ ਟਰਮੀਨਲ ਗਲਤ ਹੈ, ਪਰ ttyS1 ਤੇ ਲਾਗਇਨ ਕਰਨਾ ਠੀਕ ਹੈ (ਕਿਉਂਕਿ ਤੁਸੀਂ ttyS1 ਨੂੰ Getty ਤੇ ਤਰਕ ਦਿੱਤਾ ਹੈ). ਸਟੈਂਡਰਡ ਇੰਪੁੱਟ ਅਤੇ ਆਉਟਪੁਟ ttyS1 ਲਈ ਨਿਰਧਾਰਤ ਕੀਤੇ ਹਨ ਭਾਵੇਂ ਕਿ ਕੰਟਰੋਲਿੰਗ ਟਰਮੀਨਲ ਰਹਿੰਦਾ ਹੈ tty11. TtyS1 ਤੇ ਚੱਲ ਰਹੇ ਹੋਰ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਇਹ ਸਟੈਂਡਰਡ ਇਨਪੁਟ / ਆਉਟਪੁਟ (ਜੋ ਕਿ ttyS1 ਨਾਲ ਜੁੜਿਆ ਹੈ) ਪ੍ਰਾਪਤ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਹਰ ਚੀਜ਼ ਠੀਕ ਹੈ. ਪਰ ਕੁਝ ਪ੍ਰੋਗਰਾਮ ਆਪਣੇ ਕੰਟਰੋਲਿੰਗ ਟਰਮੀਨਲ (tty1) ਤੋਂ ਪੜ੍ਹਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਦੀ ਗਲਤੀ ਕਰ ਸਕਦੇ ਹਨ ਜੋ ਗਲਤ ਹੈ. ਹੁਣ tty1 ਇਹ ਸੋਚ ਸਕਦਾ ਹੈ ਕਿ ਇਹ ਪ੍ਰੋਗਰਾਮ ਪਿੱਠਭੂਮੀ ਵਿੱਚ tty1 ਦੁਆਰਾ ਚਲਦੇ ਹਨ ਤਾਂ ਕਿ tty1 ਤੋਂ ਪੜ੍ਹਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਜਾ ਸਕੇ (ਇਹ ttyS1 ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ) ਜੋ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਰੋਕਣ ਦਾ ਨਤੀਜਾ ਹੈ ਜੋ ਪੜ੍ਹਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਹੈ. (ਇੱਕ ਪਿੱਠਭੂਮੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਇਸ ਦੇ ਕੰਟਰੋਲਿੰਗ ਟਰਮੀਨਲ ਤੋਂ ਪੜ੍ਹਨ ਦੀ ਆਗਿਆ ਨਹੀਂ ਹੈ.). ਤੁਸੀਂ ਇੱਕ ਸੁਨੇਹਾ ਵੇਖ ਸਕਦੇ ਹੋ ਜਿਵੇਂ ਕਿ: " [1] + ਬੰਦ ਕੀਤਾ ਗਿਆ " ਸਕ੍ਰੀਨ ਤੇ. ਇਸ ਸਮੇਂ ਤੁਸੀਂ ਫਸ ਗਏ ਹੋ ਕਿਉਂਕਿ ਤੁਸੀਂ ਅਜਿਹੀ ਪ੍ਰਕਿਰਿਆ ਨਾਲ ਇੰਟਰੈਕਟ ਨਹੀਂ ਕਰ ਸਕਦੇ ਜੋ ਤੁਹਾਡੇ ਨਾਲ ਗਲਤ ਟਰਮੀਨਲ ਰਾਹੀਂ ਸੰਚਾਰ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਿਹਾ ਹੈ. ਇਸ ਤੋਂ ਬਚਣ ਲਈ ਤੁਸੀਂ ਕਿਸੇ ਹੋਰ ਟਰਮੀਨਲ ਤੇ ਜਾ ਸਕਦੇ ਹੋ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਮਾਰ ਸਕਦੇ ਹੋ.

ਐਂਟੀਜੇਟੀ (ਹੋਸਟਟੀ ਦਾ ਨਾਂ ਮਿਲ ਗਿਆ ਹੈ)

/ Etc / inittab ਵਿੱਚ ਇੱਕ ਉਦਾਹਰਨ ਲਾਈਨ:

S1: 23: respawn: / sbin / getty -l 19200 ttyS1 vt102

S1 ttyS1 ਤੋਂ ਹੈ 23 ਦਾ ਮਤਲਬ ਹੈ ਕਿ Getty ਨੂੰ ਰੋਲ ਲੈਵਲ 2 ਜਾਂ 3. ਦਾਖਲ ਹੋਣ ਤੇ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ. Respawn ਦਾ ਭਾਵ ਹੈ ਕਿ ਜੇ Getty (ਜਾਂ ਇਸ ਨੂੰ ਬਦਲਿਆ ਕਾਰਜ ਜਿਵੇਂ ਕਿ bash) ਨੂੰ ਮਾਰ ਦਿੱਤਾ ਗਿਆ ਹੈ, getty ਆਟੋਮੈਟਿਕਲੀ (respawn) ਮੁੜ ਸ਼ੁਰੂ ਕਰੇਗੀ. / sbin / getty ਹੈ getty ਕਮਾਂਡ. The -L ਦਾ ਮਤਲਬ ਹੈ ਲੋਕਲ (ਮਾਡਮ ਕੰਟਰੋਲ ਸੰਕੇਤ ਦੀ ਅਣਦੇਖੀ). -h (ਉਦਾਹਰਣ ਵਿੱਚ ਨਹੀਂ ਦਿਖਾਇਆ ਗਿਆ) ਹਾਰਡਵੇਅਰ ਪ੍ਰਵਾਹ ਨਿਯੰਤਰਣ (ਸਟਟੀ crtscts ਵਾਂਗ ਹੀ) ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ 19200 ਬੌਡ ਦਰ ਹੈ ttyS1 ਦਾ ਮਤਲਬ ਹੈ / dev / ttyS1 (COM2 ਵਿੱਚ MS-DOS). vt102 ਟਰਮਿਨਲ ਦੀ ਕਿਸਮ ਹੈ ਅਤੇ ਇਹ getty ਇਸ ਵੇਲ੍ਹ ਨੂੰ ਵਾਤਾਵਰਨ ਵੇਅਰਿਏਬਲ TERM ਨਿਰਧਾਰਤ ਕਰੇਗਾ. ਕੋਈ ਵੀ ਸੰਰਚਨਾ ਫਾਇਲਾਂ ਨਹੀਂ ਹਨ. Getty ਸੰਪਾਦਿਤ ਕਰਨ ਦੇ ਬਾਅਦ ਕਮਾਂਡ ਲਾਈਨ ਤੇ "init q" ਟਾਈਪ ਕਰੋ ਅਤੇ ਤੁਹਾਨੂੰ ਇੱਕ ਲੌਗਿਨ ਪ੍ਰੌਮਪਟ ਵੇਖਣਾ ਚਾਹੀਦਾ ਹੈ.

ਅਗੇਟੀ ਦੀ ਸਿਫ਼ਟੀ ਸਮੱਸਿਆਵਾਂ ਦੀ ਸਵੈ-ਖੋਜ

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

ਸਮਾਨਤਾ ਵੇਚਣ ਵਾਲੇ ਪਰੌਂਪਟ ਆਉਣ ਵਾਲੇ ਲੋਕਾਂ ਨੂੰ ਦਾਖਲ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਤੋਂ ਰੋਕਦਾ ਹੈ. ਇਹ ਉਹੀ ਹੋ ਸਕਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ

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

ਗ਼ਲਤ ਪੈਰਾਟ ਨਾਲ, ਲੌਗਇਨ ਪ੍ਰੋਗ੍ਰਾਮ ਸਹੀ ਢੰਗ ਨਾਲ ਨਹੀਂ ਪੜ੍ਹ ਸਕਦਾ ਜੋ ਤੁਸੀਂ ਟਾਈਪ ਕਰਦੇ ਹੋ ਅਤੇ ਤੁਸੀਂ ਲੌਗ ਇਨ ਨਹੀਂ ਕਰ ਸਕਦੇ. ਜੇ ਤੁਹਾਡਾ ਟਰਮੀਨਲ ਪ੍ਰਾਪਤ ਪੈਰੀਟੀ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਇੱਕ ਗਿਰਕੋਡ ਸਕ੍ਰੀਨ ਦੇਖਣਾ ਜਾਰੀ ਰੱਖੋਗੇ. ਜੇ Getty ਪੈਰਾਟੀ ਨੂੰ ਖੋਜਣ ਵਿੱਚ ਅਸਫਲ ਹੋ ਜਾਂਦੀ ਹੈ ਇੱਕ / etc / issue ਫਾਇਲ ਆਮ ਤੌਰ ਤੇ ਪਰੌਂਪਟ ਤੋਂ ਪਹਿਲਾਂ ਸਕਰੀਨ ਉੱਤੇ ਡੰਪ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਇਸ ਲਈ ਸਕਰੀਨ ਤੇ ਹੋਰ ਗੜਬੜ ਵਾਲੇ ਸ਼ਬਦ ਪ੍ਰਗਟ ਹੋ ਸਕਦੇ ਹਨ.

ਪਹਿਲੀ ਚਿੱਠੀ ਟਾਈਪ ਕਰਕੇ ਸੰਜਮ ਦੀ ਪਛਾਣ ਕਿਉਂ ਨਹੀਂ ਹੋ ਸਕਦੀ? ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਨ ਹੈ: ਮੰਨ ਲਓ ਕਿ ਇਹ 8-ਬਿੱਟ ਬਾਈਟ ਨੂੰ ਇਸਦੇ ਬਰਾਬਰ ਬਿੱਟ 0 (ਹਾਈ-ਆਰਡਰ ਬਿੱਟ) ਅਤੇ 1-ਬਿਟਸ ਦੀ ਬੇਤਰਤੀਬ ਗਿਣਤੀ ਨਾਲ ਖੋਜਦਾ ਹੈ. ਇਹ ਕੀ ਹੈ? ਠੀਕ, 1 ਬਿੱਟ ਦੀ ਅਜੀਬ ਗਿਣਤੀ ਦਾ ਮਤਲੱਬ ਹੈ ਕਿ ਇਹ ਇਕਸਾਰ ਸਮਾਨਤਾ ਹੈ. ਪਰ ਇਹ ਇਕ 8-ਬਿੱਟ ਅੱਖਰ ਵੀ ਹੋ ਸਕਦਾ ਹੈ ਜਿਸਦਾ ਕੋਈ ਸਮਾਨਤਾ ਨਹੀਂ ਹੈ. ਇਸ ਤੋਂ ਪਤਾ ਲਗਾਉਣ ਲਈ ਅਜੇ ਤੱਕ ਕੋਈ ਤਰੀਕਾ ਨਹੀਂ ਹੈ. ਪਰ ਹੁਣ ਤੱਕ ਅਸੀਂ ਵੀ ਬਰਾਬਰੀ ਦੀ ਸੰਭਾਵਨਾ ਨੂੰ ਖਤਮ ਕਰ ਦਿੱਤਾ ਹੈ. ਸਮਾਨਤਾ ਦੀ ਖੋਜ ਇਸ ਤਰ੍ਹਾਂ ਖਤਮ ਹੋਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦੁਆਰਾ ਚਲੀ ਜਾਂਦੀ ਹੈ.

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

ਕਿਸੇ ਨੂੰ "ਲੌਗਿਨ ਲੂਪ" ਵਿੱਚ ਕਈ ਤਰੀਕਿਆਂ ਨਾਲ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ. ਮੰਨ ਲਓ ਤੁਸੀਂ ਸਿਰਫ ਆਪਣੇ ਲੌਗਇਨ ਨਾਮ ਲਈ ਇਕ ਜਾਂ ਦੋ ਅੱਖਰ ਟਾਈਪ ਕਰਦੇ ਹੋ ਅਤੇ ਫਿਰ ਵਾਪਸ ਪਰਤੋ ਜੇ ਇਹ ਅੱਖਰ ਸਮਾਨਤਾ ਦੀ ਜਾਂਚ ਲਈ ਕਾਫੀ ਨਹੀਂ ਹਨ, ਤਾਂ ਬਰਾਬਰੀ ਲੱਭਣ ਤੋਂ ਪਹਿਲਾਂ ਇਹਨਾਂ ਨੂੰ ਚਲਾਓ. ਕਈ ਵਾਰੀ ਇਹ ਸਮੱਸਿਆ ਆਉਂਦੀ ਹੈ ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਟਰਮੀਨਲ ਤੇ ਨਹੀਂ ਹੈ ਅਤੇ / ਜਾਂ ਜਦੋਂ ਐਗਰੀਟਿਟੀ ਪਹਿਲਾਂ ਚਾਲੂ ਹੁੰਦੀ ਹੈ ਤਾਂ ਜੁੜਿਆ ਹੋਵੇ.

ਜੇ ਤੁਸੀਂ ਇਸ "ਲੌਗਿਨ ਲੂਪ" ਵਿੱਚ ਫਸ ਜਾਂਦੇ ਹੋ ਤਾਂ ਇਸ ਤੋਂ ਬਾਹਰ ਨਿਕਲਣ ਦਾ ਤਰੀਕਾ ਕਈ ਵਾਰ ਰਿਟਰਨ ਕੁੰਜੀ ਨੂੰ ਦਬਾਉਣਾ ਹੈ ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਗੈਟਟੀ ਲਾਗਇਨ ਪ੍ਰੌਮਿੰਟ ਪ੍ਰਾਪਤ ਨਹੀਂ ਕਰਦੇ. ਇਕ ਹੋਰ ਤਰੀਕਾ ਹੈ ਕਿ ਸਿਰਫ ਇੱਕ ਮਿੰਟ ਲਈ ਉਡੀਕ ਕਰਨੀ. ਫਿਰ Getty ਪ੍ਰੋਗ੍ਰਾਮ ਨੂੰ ਗ੍ਰੀਟੀ ਪ੍ਰੋਗਰਾਮ ਦੁਆਰਾ ਸਕ੍ਰੀਨ ਤੇ ਪਾ ਦਿੱਤਾ ਜਾਵੇਗਾ ਅਤੇ ਤੁਸੀਂ ਦੁਬਾਰਾ ਲਾਗਇਨ ਕਰਨ ਲਈ ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦੇ ਹੋ.

8-ਬਿੱਟ ਡਾਟਾ ਬਾਈਟ (ਅਤੇ ਸਮਾਨਤਾ)

ਬਦਕਿਸਮਤੀ ਨਾਲ, ਐਗਰਟੀ ਇਸ ਪੈਰੀਟੀ ਨੂੰ ਨਹੀਂ ਪਛਾਣ ਸਕਦੀ. 1999 ਦੇ ਅਖੀਰ ਵਿੱਚ ਇਸ ਦਾ ਕੋਈ ਵਿਕਲਪ ਨਹੀਂ ਹੈ, ਜਿਸ ਨਾਲ ਪੈਰਾਟ ਦੀ ਆਟੋ-ਖੋਜ ਨੂੰ ਅਯੋਗ ਕੀਤਾ ਜਾ ਸਕੇ ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਗਲਤ ਸਮਾਨਤਾ ਨੂੰ ਪਛਾਣਿਆ ਜਾ ਸਕੇ. ਨਤੀਜਾ ਇਹ ਹੈ ਕਿ ਲਾਗਇਨ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਗੜਬੜ ਦਿੱਤਾ ਜਾਵੇਗਾ ਅਤੇ ਪੈਰਿਟੀ ਨੂੰ ਗਲਤ ਸੈੱਟ ਕੀਤਾ ਜਾਵੇਗਾ. ਇਸ ਲਈ ਇਹ ਸਿਧਾਂਤ ਦੇ ਨਾਲ 8-ਬਿੱਟ ਡਾਟਾ ਬਾਈਟ ਵਰਤਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਯੋਗ ਨਹੀਂ ਲਗਦਾ.

getty (getty_ps ਦਾ ਹਿੱਸਾ)

(ਇਹ ਦੇ ਜ਼ਿਆਦਾਤਰ ਗ੍ਰੈਗ ਹੈਨਕਿਨ ਦੁਆਰਾ ਪੁਰਾਣੇ ਸੀਰੀਅਲ-ਹੋਵਟੋ ਤੋਂ ਹੈ)
ਇਸ Getty ਲਈ ਇੱਕ ਨੂੰ ਦੋਨਾਂ ਨੂੰ ਇੱਕ ਸੰਰਚਨਾ ਫਾਇਲ ਵਿੱਚ ਇੰਦਰਾਜ਼ ਰੱਖਣੇ ਅਤੇ / etc / inittab ਵਿੱਚ ਇੱਕ ਐਂਟਰੀ ਸ਼ਾਮਿਲ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ. ਇੱਥੇ ਕੁਝ ਉਦਾਹਰਨ ਐਂਟਰੀਆਂ ਹਨ ਜੋ ਤੁਹਾਡੇ ਟਰਮੀਨਲ ਲਈ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਜੋ ਕਿ ਤੁਸੀਂ / etc / gettydefs ਸੰਰਚਨਾ ਫਾਇਲ ਵਿੱਚ ਪਾ ਸਕਦੇ ਹੋ.

# 38400 bps ਡਮ ਟਰਮੀਨਲ ਐਂਟਰੀ DT38400 # B38400 CS8 CLOCAL # B38400 SANE -ISTRIP CLOCAL # @ S @ ਲ ਲੌਗਿਨ: # DT38400 # 19200 ਬੱਸ ਡੈਮ ਟਰਮੀਨਲ ਐਂਟਰੀ ਡੀ ਟੀ19200 # ਬੀ 19200 CS8 CLOCAL # B19200 SANE -ISTRIP CLOCAL # @ ਐਸ @ ਐਲ ਲੌਗਿਨ: # ਡੀ ਟੀ19200 # 9600 ਬੀਪੀਸ ਡਮ ਟਰਮੀਨਲ ਐਂਟਰੀ ਡੀ.ਟੀ 9600 # ਬੀ 9600 ਸੀਐਸਐਲ CLOCAL # ਬੀ 9600 ਸੈਨ -ਇਸਟਿਪ ਕੋਲੋਕਲ # @ ਐਸ ਐਮ ਐਲ ਲੌਗਿਨ: # ਡੀ ਟੀ 9600

ਨੋਟ ਕਰੋ ਕਿ DT38400, DT19200, ਆਦਿ ਸਿਰਫ ਲੇਬਲ ਹਨ ਅਤੇ ਉਹੀ ਉਹੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜੋ ਤੁਸੀਂ / etc / inittab ਵਿੱਚ ਵਰਤਦੇ ਹੋ.

ਜੇ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਲੌਗਇਨ ਬੈਨਰ ਵਿੱਚ Getty ਛਾਪਣ ਦੀਆਂ ਦਿਲਚਸਪ ਗੱਲਾਂ ਕਰ ਸਕਦੇ ਹੋ. ਮੇਰੇ ਉਦਾਹਰਣਾਂ ਵਿੱਚ, ਮੇਰੇ ਕੋਲ ਸਿਸਟਮ ਦਾ ਨਾਮ ਹੈ ਅਤੇ ਸੀਰੀਅਲ ਲਾਈਨ ਪ੍ਰਿੰਟ ਕੀਤੀ ਗਈ ਹੈ. ਤੁਸੀਂ ਹੋਰ ਚੀਜ਼ਾਂ ਜੋੜ ਸਕਦੇ ਹੋ: [ਬਲਾਕਕੋਟ

ਸ਼ੇਡ = ਹਾਂ] @ ਬੀ ਮੌਜੂਦਾ (@ ਬੀ ਦੇਖਿਆ ਗਿਆ ਹੈ ਉਸ ਸਮੇਂ ਦਾ ਮੁਲਾਂਕਣ ਕੀਤਾ ਗਿਆ ਹੈ) ਬੀ ਪੀ ਰੇਟ. @ ਡੀ ਮੌਜੂਦਾ ਤਾਰੀਖ, MM / DD / YY ਵਿੱਚ. @ ਐਲ ਸੀਰੀਅਲ ਲਾਈਨ ਜਿਸ ਨਾਲ ਗੈਟਟੀ ਜੁੜੀ ਹੋਈ ਹੈ. @ ਐਸ ਸਿਸਟਮ ਦਾ ਨਾਮ @T ਮੌਜੂਦਾ ਸਮਾਂ, ਐਚ ਐਚ: ਐਮਐਮ: ਐਸ ਐਸ (24 ਘੰਟੇ) ਵਿੱਚ. @ ਯੂ ਵਰਤਮਾਨ ਸਮੇਂ ਸਾਈਨ-ਇਨ ਕੀਤੇ ਉਪਭੋਗਤਾਵਾਂ ਦੀ ਗਿਣਤੀ ਇਹ / etc / utmp ਫਾਇਲ ਵਿੱਚ ਐਂਟਰੀਆਂ ਦੀ ਗਿਣਤੀ ਹੈ ਜੋ ਨਾ-ਨਲ ਯੂਟ_name ਫੀਲਡ ਵਿੱਚ ਹੈ. @V VERSION ਦਾ ਮੁੱਲ, ਜਿਵੇਂ ਕਿ ਡਿਫਾਲਟ ਫਾਈਲ ਵਿੱਚ ਦਿੱਤਾ ਗਿਆ ਹੈ. ਇੱਕ '@' ਅੱਖਰ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ, '\ @' ਜਾਂ '@@' ਵਰਤੋ.

ਜਦੋਂ ਤੁਸੀਂ / etc / gettydefs ਸੋਧ ਕਰ ਰਹੇ ਹੋ, ਤੁਸੀਂ ਇਹ ਤਸਦੀਕ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਸਿੰਟੈਕਸ ਇਹ ਕਰਕੇ ਸਹੀ ਹੈ:

linux # getty -c / etc / gettydefs

ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਸੀਰੀਅਲ ਪੋਰਟ ਲਈ ਕੋਈ ਹੋਰ Getty ਜਾਂ UUgetty config ਫਾਇਲ ਨਹੀਂ ਹੈ, ਜਿਸ ਨਾਲ ਤੁਹਾਡਾ ਟਰਮੀਨਲ ਜੁੜਿਆ ਹੋਇਆ ਹੈ ( /etc/default/{uu}getty.ttyS N ਜਾਂ /etc/conf.{uu}getty.ttyS N ) , ਕਿਉਂਕਿ ਇਹ ਸੰਭਵ ਤੌਰ ਤੇ ਇੱਕ ਟਰਮੀਨਲ ਤੇ getty ਚੱਲ ਰਹੀ ਹੈ. ਅਜਿਹੀਆਂ ਫਰਕ ਜਾਣ ਵਾਲੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਹਟਾਓ ਜੇ ਉਹ ਬਾਹਰ ਨਿਕਲ ਜਾਣ.

ਸੀਰੀਅਲ ਪੋਰਟ ਤੇ Getty ਨੂੰ ਚਲਾਉਣ ਲਈ ਆਪਣੀ / etc / inittab ਫਾਇਲ ਨੂੰ ਸੋਧੋ (ਤੁਹਾਡੇ ਵਾਤਾਵਰਣ - ਪੋਰਟ, ਸਪੀਡ ਅਤੇ ਡਿਫਾਲਟ ਟਰਮੀਨਲ ਕਿਸਮ ਲਈ ਸਹੀ ਜਾਣਕਾਰੀ ਵਿੱਚ ਬਦਲਣਾ):

ਸ1: 23: ਰੇਸ਼ਾਨ: / ਸਿਨਬ / ਗੈਟਟੀ ttyS1 ਡੀਟੀ 9600 vt100 ਇਸ ਵਿੱਚ linux # init q

ਇਸ ਸਮੇਂ, ਤੁਹਾਨੂੰ ਆਪਣੇ ਟਰਮੀਨਲ ਤੇ ਇੱਕ ਲੌਗਇਨ ਪ੍ਰੌਪਟ ਵੇਖਣਾ ਚਾਹੀਦਾ ਹੈ. ਤੁਹਾਨੂੰ ਟਰਮੀਨਲ ਦਾ ਧਿਆਨ ਖਿੱਚਣ ਲਈ ਵਾਪਸੀ 'ਤੇ ਰੋਕਣਾ ਪੈ ਸਕਦਾ ਹੈ.

mgetty

"M" ਮਾਡਮ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਇਹ ਪ੍ਰੋਗਰਾਮ ਮੁੱਖ ਤੌਰ ਤੇ ਮਾਡਮ ਲਈ ਹੈ ਅਤੇ 2000 ਦੇ ਦਹਾਕੇ ਦੇ ਸਮੇਂ ਇਸ ਨੂੰ ਪਾਠ-ਟਰਮੀਨਲਾਂ ਲਈ ਵਰਤਣ ਲਈ ਮੁੜ ਕੰਪਲਿੰਗ ਦੀ ਲੋੜ ਹੋਵੇਗੀ (ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਹਾਰਡਵੇਅਰ ਪ੍ਰਵਾਹ ਨਿਯੰਤਰਣ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰਦੇ - ਅਤੇ ਇਸ ਲਈ ਆਮ ਤੌਰ ਤੇ ਹੱਥ-ਬਣੀ ਕੇਬਲ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ). ਸਿੱਧੇ ਤੌਰ ਤੇ ਜੁੜੇ ਟਰਮੀਨਲਾਂ ਲਈ ਦਸਤਾਵੇਜ਼ੀਕਰਣ ਲਈ ਦਸਤਾਵੇਜ਼ ਦੇ "ਡਾਇਰੈਕਟ" ਭਾਗ ਨੂੰ ਦੇਖੋ: mgetty.texi.

/etc/mgetty/mgetty.config ਦੀਆਂ ਆਖਰੀ ਲਾਈਨਾਂ ਨੂੰ ਟਰਮੀਨਲ ਲਈ ਸੰਰਚਿਤ ਕਰਨ ਦੇ ਇੱਕ ਉਦਾਹਰਨ ਲਈ ਵੇਖੋ. ਜਦ ਤੱਕ ਤੁਸੀਂ "ਟੌਗਲ-ਡੈਂਟ ਨੰ" ਨਹੀਂ ਕਹਿੰਦੇ ਹੋ, ਇਹ ਸੋਚਦਾ ਹੈ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਮੌਡਮ ਹੈ ਅਤੇ ਪੀਸੀ ਉੱਤੇ ਡੀ.ਟੀ.ਆਰ. ਪਿਨ ਨੂੰ ਨਕਾਰਾ ਕਰੋ (ਗ਼ੈਰ-ਮੌਜੂਦ ਮੌਡਮ) ਨੂੰ ਰੀਸੈਟ ਕਰਨ ਦੀ ਵਿਅਰਥ ਕੋਸ਼ਿਸ਼ ਵਿਚ. ਦੂਜੀ gettys ਦੇ ਉਲਟ, mgetty ਆਪਣੇ ਆਪ ਨੂੰ ਟਰਮੀਨਲ ਤੇ ਜੋੜ ਨਹੀਂ ਸਕਦਾ ਜਦੋਂ ਤੱਕ ਕੋਈ ਉਸ ਟਰਮੀਨਲ ਤੇ ਕਿਸੇ ਵੀ ਕੁੰਜੀ ਨੂੰ ਨਹੀਂ ਚਲਾਉਂਦਾ ਤਾਂ ਤੁਸੀਂ ਇੱਕ ਵੇਖੋਗੇ? ਟਰਮਿਨਲ ਲਈ, ਜਦੋਂ ਤੱਕ ਇਹ ਨਹੀਂ ਹੁੰਦਾ. / Var / log / mgetty / ਵਿੱਚ ਲੌਗ ਕੁਝ ਚੇਤਾਵਨੀ ਸੁਨੇਹਿਆਂ ਨੂੰ ਦਿਖਾ ਸਕਦਾ ਹੈ ਜੋ ਸਿਰਫ ਮਾਡਮ ਤੇ ਲਾਗੂ ਹੁੰਦੇ ਹਨ ਜੋ ਤੁਸੀਂ ਅਣਡਿੱਠ ਕਰ ਸਕਦੇ ਹੋ.

ਇੱਥੇ ਸਧਾਰਨ ਲਾਈਨ ਦੀ ਉਦਾਹਰਨ ਹੈ ਜੋ ਤੁਸੀਂ / etc / inittab ਵਿੱਚ ਪਾ ਦਿੱਤੀ ਹੈ:

s1: 23: respawn: / sbin / mgetty -r ttyS1