Character devices are read from and written to with two function: foo_read() and foo_write(). The read() and write() calls do not return until the operation is complete. By contrast, block devices do not even implement the read() and write() functions, and instead have a function which has historically been called the “strategy routine.” Reads and writes are done through the buffer cache mechanism by the generic functions bread(), breada(), and bwrite(). These functions go through the buffer cache, and so may or may not actually call the strategy routine, depending on whether or not the block requested is in the buffer cache (for reads) or on whether or not the buffer cache is full (for writes).

A request may be asyncronous: breada() can request the strategy routine to schedule reads that have not been asked for, and to do it asyncronously, in the background, in the hopes that they will be needed later.

The sources for character devices are kept in …/kernel/chr_drv/, and the sources for block devices are kept in …/kernel/blk_drv/. They have similar interfaces, and are very much alike, except for reading and writing. Because of the difference in reading and writing, initialization is different, as block devices have to register a strategy routine, which is registered in a different way than the foo_read() and foo_write()routines of a character device driver.

PORT NAME     Interrupt #     Starting I/O   Ending I/O LPT1           IRQ 7          0×378           0x37f LPT2           IRQ 5           0×278           0x27f

• In this exercise we use LPT1 with IRQ 7 and the following three bytes:
  1. 0×378 : data port
  2. 0×379 : status port
  3. 0x37A : control port
• The parallel port standard states that setting bit C4 of the control port (0x37A) enables interrupt reporting.

The pins of the 25 pin female D type parallel port connector are shown in the following picture

• In this picture all green pins (numbered 18 – 25) are grounded at 0 Volt.
• When having interrupts enabled (i.e., bit C4 has been set), an interrupt will be generated by the parallel port when the voltage on input line S6 (pin 10) is raised from 0 Volt to +5 Volt. By default the input line is kept high to +5 Volt when nothing is connected. Observe that when pin 10 is shortly shorted to one of the pins 19-25, i.e., to ground, an interrupt on IRQ line 7 will be generated by the parallel port. The interrupt is generated at exactly the moment that you undo the shortage, since at that exact moment the line is raised from 0 to +5 Volt.

A timer is much easier to use. You register your function once, and the kernel calls it once when the timer expires. Such a functionality is used often within the kernel proper, but it is sometimes needed by the drivers as well, as in the example of the floppy motor. A timer is characterized by its time-out value (in jiffies) and the function to be called when the timer expires. The timer handler receives an argument, which is stored in the data structure, together with a pointer to the handler itself.

The data structure of a timer looks like the following, which is extracted from <linux/timer.h>):

 struct timer_list {
     unsigned long expires;            /* the timeout, in jiffies */
     unsigned long data;               /* argument to the handler */
     void (*function)(unsigned long);  /* handler of the timeout */
     };

These are the functions used to act on timers:

• void init_timer(struct timer_list *timer);

• void add_timer(struct timer_list *timer);

• int del_timer(struct timer_list *timer);

The code for /proc/jitimer is as follows:

struct jit_data{

struct timer_list timer;

unsigned long prev-jiffies;

unsigned char*buff;

};

Advantage:

1. Python code has to be strictly indented but the indentation helps in much cleaner code(readable).
2. High level data structures are list, directory are well suited in python. 
3. Easy to write, easy to read and easy to understand.

Example:

print '{0} and {1}'.format('spam', 'eggs')
Output=spam and eggs

The lseek() function repositions the offset of the file descriptor fildes to the argument offset according to the directive whence.
The argument fildes must be an open file descriptor. 
Lseek() repositions the file position pointer associated with the file descriptor fildes as follows:

• If whence is SEEK_SET, the offset is set to offset bytes.
• If whence is SEEK_CUR, the offset is set to its current location plus offset bytes.

• If whence is SEEK_END, the offset is set to the size of the file plus offset bytes.

The lseek() function allows the file offset to be set beyond the end of the existing end-of-file of the file.
If data is later written at this point, subsequent reads of the data in the gap return bytes of zeros (until data is actually written into the gap).

Some devices are incapable of seeking. The value of the pointer   associated with such a device is undefined.
Upon successful completion, lseek() returns the resulting offset location as measured in bytes from the beginning of the file.Otherwise, a value of -1 is returned and errno is set to indicate the error.

To set all the bytes in a block of memory to a particular value, use memset(). The function prototype is

void * memset(void *dest, int c, size_t count);

The argument dest points to the block of memory. c is the value to set, and count is the number of bytes, starting at dest, to be set. Note that while c is a type int, it is treated as a type char. In other words, only the low-order byte is used, and you can specify values of c only in the range 0 through 255.

Use memset() to initialize a block of memory to a specified value. Because this function can use only a type char as the initialization value, it is not useful for working with blocks of data types other than type char, except when you want to initialize to 0. In other words, it wouldn’t be efficient to use memset() to initialize an array of type int to the value 99, but you could initialize all array elements to the value 0.

The memcpy() Function

memcpy() copies bytes of data between memory blocks, sometimes called buffers. This function doesn’t care about the type of data being copied–it simply makes an exact byte-for-byte copy. The function prototype is

void *memcpy(void *dest, void *src, size_t count);

The arguments dest and src point to the destination and source memory blocks, respectively. count specifies the number of bytes to be copied. The return value is dest. If the two blocks of memory overlap, the function might not operate properly–some of the data in src might be overwritten before being copied.

The memmove() Function

memmove() is very much like memcpy(), copying a specified number of bytes from one memory block to another. It’s more flexible, however, because it can handle overlapping memory blocks properly. Because memmove() can do everything memcpy() can do with the added flexibility of dealing with overlapping blocks. The prototype is

void *memmove(void *dest, void *src, size_t count);

dest and src point to the destination and source memory blocks, and count specifies the number of bytes to be copied. The return value is dest. If the blocks overlap, this function ensures that the source data in the overlapped region is copied before being overwritten.

Following are some of the major differences between the thread and the processes :

• Processes do not share their address space while threads executing under same process share the address space.
• From the above point its clear that processes execute independent of each other and the synchronization between processes is taken care by kernel only while on the other hand the thread synchronization has to be taken care by the process under which the threads are executing
• Context switching between threads is fast as compared to context switching between processes
• The interaction between two processes is achieved only through the standard inter process communication while threads executing under the same process can communicate easily as they share most of the resources like memory, text segment etc

User threads Vs Kernel Threads

Threads can exist in user space as well as in kernel space.

A user space threads are created, controlled and destroyed using user space thread libraries. These threads are not known to kernel and hence kernel is nowhere involved in their processing. These threads follow co-operative multitasking where-in a thread releases CPU on its own wish ie the scheduler cannot preempt the thread. Th advantages of user space threads is that the switching between two threads does not involve much overhead and is generally very fast while on the negative side since these threads follow co-operative multitasking so if one thread gets block the whole process gets blocked.

A kernel space thread is created, controlled and destroyed by the kernel. For every thread that exists in user space there is a corresponding kernel thread. Since these threads are managed by kernel so they follow preemptive multitasking where-in the scheduler can preempt a thread in execution with a higher priority thread which is ready for execution. The major advantage of kernel threads is that even if one of the thread gets blocked the whole process is not blocked as kernel threads follow preemptive scheduling while on the negative side the context switch is not very fast as compared to user space threads.

If we talk of Linux then kernel threads are optimized to such an extent that they are considered better than user space threads and mostly used in all scenarios except where prime requirement is that of cooperative multitasking.

A server application normally listens to a specific port waiting for connection requests from a client. When a connection request arrives, the client and the server establish a dedicated connection over which they can communicate. During the connection process, the client is assigned a local port number, and binds a socket to it. The client talks to the server by writing to the socket and gets information from the server by reading from it. Similarly, the server gets a new local port number (it needs a new port number so that it can continue to listen for connection requests on the original port). The server also binds a socket to its local port and communicates with the client by reading from and writing to it.

The client and the server must agree on a protocol–that is, they must agree on the language of the information transferred back and forth through the socket.

GRUB is dynamically configurable. This means that the user can make changes during the boot time, which include altering existing boot entries, adding new, custom entries, selecting different kernels, or modifying initrd. GRUB also supports Logical Block Address mode. This means that if your computer has a fairly modern BIOS that can access more than 8GB (first 1024 cylinders) of hard disk space, GRUB will automatically be able to access all of it.

GRUB can be run from or be installed to any device (floppy disk, hard disk, CD-ROM, USB drive, network drive) and can load operating systems from just as many locations, including network drives. It can also decompress operating system images before booting them.

Message queuing allows distributed applications to communicate asynchronously by sending messages between the applications.  The messages from the sending application are stored in a queue and are retrieved by the receiving application.  The applications send or receive messages through a queue by sending a request to the message queuing system.  Sending and receiving applications can use the same message queuing system or different ones, allowing the message queuing system to handle the forwarding of the messages from the sender queue to the recipient queue.

Queued messages can be stored at intermediate nodes until the system is ready to forward them to the next node.  At the destination node, the messages are stored in a queue until the receiving application retrieves them from the queue.  Message delivery is guaranteed even if the network or application fails.  This provides for a reliable communication channel between the applications.

The complexity and details of the underlying model (to store and forward messages between different environments) are handled by the message queuing system.  By maintaining this level of abstraction, distributed applications can be developed without the need to worry about the details of how the information is transported.

Because the sending and receiving applications operate independently of one another, the sending application is less dependent on the availability of the remote application, less dependent on the network between them, and less dependent on the computer system on which the receiving application runs.  This leads to a higher level of availability for the participating applications.

Messages and message queue operations can be configured by the applications to operate in specific modes.  For example, a sending application can specify that queued messages should survive system crashes.  As another example, the receiving application can specify a maximum waiting period for a receiving operation from a queue (in case no messages are available yet on the receiving queue).

To make a semaphore,its variable should be greater the zero.To initialize a Semaphore 3 function definition are used :

1. kernel key=segmet(user key,no. of semaphores,666|IPC_CREAT);

2. semctl(kernel key,index,command,…(optional));

3. semop(kernel key,struct sembuf*sops,size of sops);

• If fork() returns a negative value, the creation of a child process was unsuccessful.
• fork() returns a zero to the newly created child process.
• fork() returns a positive value, the process ID of the child process, to the parent. The returned process ID is of type pid_t defined in sys/types.h. Normally, the process ID is an integer. Moreover, a process can use function getpid() to retrieve the process ID assigned to this process.

Due to the fact that the CPU scheduler will assign a particular time to each process, the parent or the child process will run for some time.After the calling of system call FORK the program counter of both will run simultaneously.

If threshold voltage is crossover in BRT then its an invalid bit,if not crossover then its a valid bit.Bit is a small unit of information or data.Low input is logical 0.