1. To make a process aware that a specific event has occurred.
2. To force a process to execute a signal handler function included in its code.

A number of system calls allow programmers to send signals and determine how their processes exploit the signals they receive.An important characteristic of signals is that they may be sent at any time to processes whose state is usually unpredictable. Signals sent to a non-running process must be saved by the kernel until that process resumes execution. Blocking signals (described later) require signals to be queued, which exacerbates the problem of signals being raised before they can be delivered.Therefore, the kernel distinguishes two different phases related to signal transmission:

1. Signal sending:The kernel updates the descriptor of the destination process to represent that a new signal has been sent.
2. Signal receiving: The kernel forces the destination process to react to the signal by changing its execution state or by starting the execution of a specified signal handler or both.

Each signal sent can be received no more than once. Signals are consumable resources: once they have been received, all process descriptor information that refers to their previous existence is cancelled.Signals that have been sent but not yet received are called pending signals . At any time, only one pending signal of a given type may exist for a process; additional pending signals of the same type to the same process are not queued but simply discarded. In general, a signal may remain pending for an unpredictable amount of time. Some important points about the signals are :

• When a process executes a signal-handler function, it usually “masks” the corresponding signal, that is, it automatically blocks the signal until the handler terminates.
• A signal handler therefore cannot be interrupted by another occurrence of the handled signal, and therefore the function doesn’t need to be re-entrant.
• A masked signal is always blocked, but the converse does not hold.
• The kernel must remember which signals are blocked by each process. When switching from Kernel Mode to User Mode, check whether a signal for any process has arrived.

The SIGKILL and SIGSTOP signals cannot be explicitly ignored or caught, and thus their default actions must always be executed. Therefore, SIGKILL and SIGSTOP allow a user with appropriate privileges to destroy and to stop, respectively, any process regardless of the defences taken by the program it is executing.

I am working on Character Driver on Linux from last few days.Device Driver is simply a piece of code as a part of kernel,dynamic (temporary) or static (permanent) required to make the hardware accessible to the application. Device Drivers can be classified into three basic types: Character driver, Block driver and Network driver. A character device is one that can be accessed as a stream of bytes i.e. character by character. And code needed make communication possible b/w a character device and application is character driver.
As there is a very good feature of Linux i.e. the ability to extend the set of features offered by the kernel at runtime. This means that we can add functionality to the kernel (and remove functionality as well) while the system is up and running. Each piece of code that can be added to the kernel at runtime is called a module. Different types (or classes) of modules,that can be inserted to the Linux kernel includes device drivers but not limited to this. Each module is made up of object code that can be dynamically linked to the running kernel by the insmod program and can be unlinked by the rmmod program. Whenever we do insmod, the macro ‘module_init’ invokes our initialization routine and module is inserted to the kernel if it is valid. And when rmmod is done our module gets removed from the kernel through the macro ‘module_exit’. Our initialization routine registers the driver for the devices and obtains major no. from the registration call( int register_chrdev_region(dev_t first, unsigned int count, char *name); or int alloc_chrdev_region(dev_t *dev, unsigned int firstminor, unsigned int count, char *name);) and sets up some basic parameters we’ll be using ahead e.g struct ScullDev’s elements. Also we have to initialize the resources that are going to be used.In module_exit the opposite of initialization procedure is performed in reverse order.All the resources allocated to the driver to be freed and this is done by exit routine.After our module gets inserted successfully to the kernel,it can be seen in ‘/proc/modules’ file.And if we are able to register our driver successfully, we can see the driver’s name in ‘/proc/devices’ file.
To implement our character driver we have used SCULL (Simple Character Utility for Loading Localities). Scull acts on a memory as though it were a device.The advantage of scull is that it isn’t hardware dependent. Scull just acts on some memory, allocated from the kernel. Anyone can compile and run scull.We have mapped the system calls to the routines written in our own driver i.e. we have defined the behaviour of the system calls for a particular device. We have used cdev_init and cdev_add functions to initialize the struct cdev and inform the kernel about the device. In our open routine,we are checking the mode,the device is trying to being opened. And depending on that mode flags we are performing some specific tasks e.g. if device is opened in write only mode then the device memory will get trimmed before going ahead.In trimming routine we just free all the memory allocated to the scull. Also in open routine we are mapping the scull to the device by using the macro ‘container_of’.In brief it simply maps the scull into the device and returns a pointer to the memory of device having scull mapped onto it.And we have stored this pointer into the void pointer ‘filep->private_data’ to preserve the starting address of device memory for further use. In our write routine we are writing the data from application to the device through the scull quantums by using ‘copy_from_user’.Write routine also checks for the offset value i.e. cursor position where application wants to write.In read routine we are copying data from the device through scull quantums using ‘copy_to_user’ function.Read routine also checks for the offset value from where application wants to read. We have also implemented lseek routine that sets the offset value as provided by the application in lseek system call.And finally in release routine we have just released the resources used after opening the device.

revision 1.1

date: 2013/06/26 04:18:21;  author: emblogic;  state: Exp;
Initial revision
=============================================================================

done 8 questions from 3rd assignment ,having problem in Q5:showing errors in assignment statements like

i++=j++;

and in Q8(print cycle of sine and cosine wave),i don’t understand what to do in program;

overall enjoying C…..

1) Q10(assignment 1) integer overflow:why unsigned int always gives the maximum value(4294967295) possible for it on overflow;as char gives 0 on 1 overflow???

2)what exactly happens here::

int p=5;

printf(%d\t%d\t%d\t%d\n,++p,p++,p,++p);