GATE CSE 2008 | Question: 34

Question

Which of the following must be true for the RFE (Return From Exception) instruction on a general purpose processor?

1. It must be a trap instruction

2. It must be a privileged instruction

3. An exception cannot be allowed to occur during execution of an RFE instruction

• A. I only
• B. II only
• C. I and II only
• D. I, II and III only

Comments

Here are my thoughts.. please give your rebuttals

1. why must it be a trap instruction? I find no reason that it has to be a trap. No referenced link in this post says it has to be a trap.

2. It has to be a privileged instruction because it accesses kernel stack in the newer OS. Although in older OS, there was no concept of kernel space and user space, it was one huge address space.

3. An exception cannot be allowed to occur? Aborts and faults (they are exceptions too) can occur during the execution of any instruction. It's like saying power failure is not allowed to happen when RFE is executing.

I think the answer should be II only

---

Transitions from kernel to user mode are performed explicitly by the
operating system, generally at the end of an interrupt handler or
kernel call, using a privileged RFE (return from exception) instruction.

 

I found this from the link

---

https://www.cse.iitk.ac.in/users/biswap/CS422/L8-Exceptions.pdf

Refer page 11

Answer 1

RFE (Return From Exception) is a privileged trap instruction that is executed when exception occurs, so an exception is not allowed to execute. (D) is the correct option.

Reference: http://www.cs.rochester.edu/courses/252/spring2014/notes/08_exceptions

Comments

Nowhere does the referenced link say that RFE is a trap instruction

---

exact use of the terms "interrupt", "exception", "trap", and "fault" varies from author to author and machine to machine

http://www.cs.rochester.edu/courses/252/spring2014/notes/08_exceptions

 

Maybe Statement I is true, because Statement II is true.

---

Divy Kala the reference says that trap instructions are those instructions which r called by a program causing a system call. Since RFE is a system call (obviously since kernel to user mode can only be done by OS and thats what RFE does) and because the exception handler itself is a program hence we can say RFE is a trap instruction itself, 

Correct me if i am wrong.

Answer 2

As already told in other answers, RFE is a privileged trap instruction. The purpose of RFE is to switch from kernel mode to user mode once the system is done with handling an exception (any interrupt, trap or fault).

Now, let us approach this question through the points given.

1. It must be a trap instruction - Definitely it must be a trap instruction as RFE is an explicit privileged instruction causing a switch from kernel to user mode

2. It must be a privileged instruction - Yes, because RFE can be executed only in supervisor/kernel mode

3. An exception cannot be allowed to occur during execution of an RFE instruction - Yes, because as soon as a trap/interrupt starts being processed all other traps/interrupts are disabled until the current instruction execution is complete.

So, all three are true and answer is (D)

Comments

I don't agree with your 3rd point. In priority based interrupt handling, while a lower priority interrupt is being serviced, if a higher priority interrupt happens, the higher priority interrupt will immediately get serviced.

The correct reasoning here is that RFE is an "instruction", so it is atomic. An exception is checked and executed only after the current instruction has finished executing.

---

Can someone refer this question https://gateoverflow.in/706/gate2001-1-13 and clear the doubt as to what is the correct answer. As both question’s answer are contradicting each other.

Privileged mode==kernel mode
Non privileged mode==user mode
From kernel to user mode, a non privileged instruction is required.
From user to kernel mode., a software interrupt is required.

This is given by @Bikram sir .

However,

Transitions from kernel to user mode are performed explicitly by the
operating system, generally at the end of an interrupt handler or
kernel call, using a privileged RFE (return from exception) instruction.

Source :– https://www.cs.rochester.edu/courses/252/spring2014/notes/08_exceptions

 

Can someone verify this and clear the doubt and contradictions both questions are creating.

@arjun Sir @Bikram Sir

---

i have same doubt as yours

---

I believe OPTION C is correct.

Answer 3

Trap is something that is requested by the program(syscall).

It is a privilege instruction and also while returning from interrupts we should have other interrupts to interrupt this process. so it must be disabled

so (D)

Answer 4

In Computer Organization & Architecture (COA), RFE (Return From Exception) is a special, privileged instruction used by the Operating System (OS) to exit an exception handler and resume normal program execution, typically switching back to user mode from kernel mode after an interrupt or fault is handled. It's crucial for managing control flow, enabling interrupts again, and restoring the processor's state to where it left off before the exception occurred. 

Key Characteristics of RFE:

• Privileged Instruction: Only the OS can execute RFE, as it controls system-level transitions.
• Trap Instruction: It's part of the exception handling mechanism, designed to transfer control to the OS when an exception happens.
• Restores State: Before executing RFE, the OS saves necessary registers; RFE restores these, including the program counter, to return to the interrupted instruction.
• Enables Further Interrupts: It often re-enables interrupts, allowing the system to respond to new events after handling the current one.
• Mode Switch: It facilitates the transition from kernel mode (where exceptions are handled) back to user mode (where the application runs). 

How it Works (Simplified):

1. Exception Occurs: An event (like a page fault or system call) disrupts normal execution.
2. Control to OS: The CPU saves the current state and jumps to the OS's exception handler (kernel mode).
3. Handler Executes: The OS handler diagnoses the issue, performs necessary actions (e.g., loading a page into memory, servicing I/O).
4. RFE Executed: The handler ends by executing RFE, which restores the saved state and resumes the user program.