The memory management subsystem is one of the most important parts of the operating system. Since the early days of computing, there has been a need for more memory than exists physically in a system. Strategies have been developed to overcome this limitation and the most successful of these is virtual memory. Virtual memory makes the system appear to have more memory than is physically present by sharing it among competing processes as they need it.

Virtual memory does more than just make your computer’s memory go farther. The memory management subsystem provides:

Large Address Spaces

The operating system makes the system appear as if it has a larger amount of memory than it actually has. The virtual memory can be many times larger than the physical memory in the system. 

Protection

Each process in the system has its own virtual address space. These virtual address spaces are completely separate from each other and so a process running one application cannot affect another. Also, the hardware virtual memory mechanisms allow areas of memory to be protected against writing. This protects code and data from being overwritten by rogue applications. 

Memory Mapping

Memory mapping is used to map image and data files into a process’ address space. In memory mapping, the contents of a file are linked directly into the virtual address space of a process. 

Fair Physical Memory Allocation

The memory management subsystem allows each running process in the system a fair share of the physical memory of the system. 

Shared Virtual Memory

Although virtual memory allows processes to have separate (virtual) address spaces, there are times when you need processes to share memory. For example there could be several processes in the system running the bash command shell. Rather than have several copies of bash, one in each process’s virtual address space, it is better to have only one copy in physical memory and all of the processes running bash share it. Dynamic libraries are another common example of executing code shared between several processes.Shared memory can also be used as an Inter Process Communication (IPC) mechanism, with two or more processes exchanging information via memory common to all of them. Linux supports the Unix System V shared memory IPC.

Virtual Memory

 

An Abstract Model of Virtual Memory

 

s

Figure: Abstract model of Virtual to Physical address mapping

 

Before considering the methods that Linux uses to support virtual memory it is useful to consider an abstract model that is not cluttered by too much detail.

As the processor executes a program it reads an instruction from memory and decodes it. In decoding the instruction, the processor may need to fetch or store the contents of a location in memory. The processor then executes the instruction and moves on to the next instruction in the program. In this way the processor is always accessing memory either to fetch instructions or to fetch and store data.

In a virtual memory system all of these addresses are virtual addresses and not physical addresses. These virtual addresses are converted into physical addresses by the processor based on information held in a set of tables maintained by the operating system.

To make this translation easier, virtual and physical memory are divided into handy sized chunks called pages. These pages are all the same size. They need not be but if they were not, the system would be very hard to administer. Linux on Alpha AXP systems uses 8 Kbyte pages and on Intel x86 systems it uses 4 Kbyte pages. Each of these pages is given a unique number: the page frame number (PFN).

In this paged model, a virtual address is composed of two parts: an offset and a virtual page frame number. If the page size is 4 Kbytes, bits 1-10 of the virtual address contain the offset and bits 12 and above are the virtual page frame number. The processor extracts the virtual page frame number and offset from a virtual address every time it encounters one. Then it matches the virtual page frame number to a physical page and uses the offset to specify how far to go into the page. The processor uses page tables to match the virtual page frame number to the physical page.

The figure above shows the virtual address spaces of two processes, process X and process Y, each with their own page tables. These page tables map each process’ virtual pages into physical pages in memory. This shows that process X’s virtual page frame number 0 is mapped into memory in physical page frame number 1 and that process Y’s virtual page frame number 1 is mapped into physical page frame number 4. Each entry in the page table contains the following information:

 

• Valid flag. This indicates if this page table entry (PTE) is valid,
• The physical page frame number that this entry describes
• Access control information. This describes how the page may be used. Can it be written to? Does it contain executable code?

The page table is accessed using the virtual page frame number as an offset. Virtual page frame 5 would be the 6th element of the table (0 is the first element).

To translate a virtual address into a physical one, the processor must first work out the virtual address’ page frame number and the offset within that virtual page. By making the page size a power of 2 this can be easily done by masking and shifting. Looking again at the figures and assuming a page size of 0×2000 bytes (which is decimal 8192) and an address of 0×2194 in process Y’s virtual address space then the processor would translate that address into offset 0×194 into virtual page frame number 1.

The processor uses the virtual page frame number as an index into the process’ page table to retrieve its page table entry. If the page table entry at that offset is valid, the processor takes the physical page frame number from this entry. If the entry is invalid, the process has accessed a non-existent area of its virtual memory. In this case, the processor cannot resolve the address and must pass control to the operating system so that it can fix things up.

Just how the processor notifies the operating system that the correct process has attempted to access a virtual address for which there is no valid translation is specific to the processor. However the processor delivers it, this is known as a page fault and the operating system is notified of the faulting virtual address and the reason for the page fault.

For a valid page table entry, the processor takes that physical page frame number and multiplies it by the page size to get the address of the base of the page in physical memory. Finally, the processor adds in the offset to the instruction or data that it needs.

Using the above example again, process Y’s virtual page frame number 1 is mapped to physical page frame number 4 which starts at0×8000 (4 x 0×2000). Adding in the 0×194 byte offset gives us a final physical address of 0×8194.

By mapping virtual to physical addresses this way, the virtual memory can be mapped into the system’s physical pages in any order. In the figure above, process X’s virtual page frame number 0 is mapped to physical page frame number 1, whereas virtual page frame number 7 is mapped to physical page frame number 0 although it is higher in virtual memory than virtual page frame number 0. This demonstrates an interesting byproduct of virtual memory; the pages of virtual memory do not have to be present in physical memory in any particular order.

 

Shared Virtual Memory

Virtual memory makes it easy for several processes to share memory. All memory access are made via page tables and each process has its own separate page table. For two processes sharing a physical page of memory, its physical page frame number must appear in a page table entry in both of their page tables.

The figure above shows two processes that each share physical page frame number 4. For process X this is virtual page frame number 4 whereas for process Y this is virtual page frame number 6. This illustrates an interesting point about sharing pages: the shared physical page does not have to exist at the same place in virtual memory for any or all of the processes sharing it.

 

Physical and Virtual Addressing Modes

It does not make much sense for the operating system itself to run in virtual memory. This would be a nightmare situation where the operating system must maintain page tables for itself. Most multi-purpose processors support the notion of a physical address mode as well as a virtual address mode. Physical addressing mode requires no page tables and the processor does not attempt to perform any address translations in this mode. The Linux kernel is linked to run in physical address space.

The Alpha AXP processor does not have a special physical addressing mode. Instead, it divides up the memory space into several areas and designates two of them as physically mapped addresses. This kernel address space is known as KSEG address space and it encompasses all addresses upwards from 0xfffffc0000000000. In order to execute from code linked in KSEG (by definition, kernel code) or access data there, the code must be executing in kernel mode. The Linux kernel on Alpha is linked to execute from address0xfffffc0000310000.

 

Access Control

The page table entries also contain access control information. As the processor is already using the page table entry to map a process’ virtual address to a physical one, it can easily use the access control information to check that the process is not accessing memory in a way that it should not.

There are many reasons why you would want to restrict access to areas of memory. Some memory, such as that containing executable code, is naturally read only memory; the operating system should not allow a process to write data over its executable code. By contrast, pages containing data can be written to, but attempts to execute that memory as instructions should fail. Most processors have at least two modes of execution: kernel and user. This adds a level of security to your operating system. Because it is the core of the operating system and therefore can do most anything, kernel code is only run when the CPU is in kernel mode. You would not want kernel code executed by a user or kernel data structures to be accessible except when the processor is running in kernel mode.

1. What is the difference between Swapping and Paging?

 

Swapping: Whole process is moved from the swap device to the main memory for execution. Process size must be less than or equal to the available main memory. It is easier to implementation and overhead to the system. Swapping systems does not handle the memory more flexibly as compared to the paging systems.

Paging: Only the required memory pages are moved to main memory from the swap device for execution. Process size does not matter. Gives the concept of the virtual memory. It provides greater flexibility in mapping the virtual address space into the physical memory of the machine. Allows more number of processes to fit in the main memory simultaneously. Allows the greater process size than the available physical memory. Demand paging systems handle the memory more flexibly.

 3.What is the main goal of the Memory Management?

 

1. It decides which process should reside in the main memory,
2. Manages the parts of the virtual address space of a process which is non-core resident,
3. Monitors the available main memory and periodically write the processes into the swap device to provide more processes fit in the main memory simultaneously.

 

4. What is a Map?

 

A Map is an Array, which contains the addresses of the free space in the swap device that are allocatable resources, and the number of the resource units available there.

Address Units
1     10,000

This allows First-Fit allocation of contiguous blocks of a resource. Initially the Map contains one entry – address (block offset from the starting of the swap area) and the total number of resources.

Kernel treats each unit of Map as a group of disk blocks. On the allocation and freeing of the resources Kernel updates the Map for accurate information.

5. What is a Region?

A Region is a continuous area of a process’s address space (such as text, data and stack). The kernel in a “Region Table” that is local to the process maintains region. Regions are sharable among the process.

 What is Fork swap?

“fork()” is a system call to create a child process. When the parent process calls “fork()” system call, the child process is created and if there is short of memory then the child process is sent to the read-to-run state in the swap device, and return to the user state without swapping the parent process. When the memory will be available the child process will be swapped into the main memory.

Static Linking and Static Libraries is the result of the linker making copy of all used library functions to the executable file. Static Linking creates larger binary files, and need more space on disk and main memory. Examples of static libraries (libraries which are statically linked) are, .a files in Linux and .lib files in Windows.

Steps to create a static library Let us create and use a Static Library in UNIX or UNIX like OS.
1. Create a C file that contains functions in your library.

We have created only one file for simplicity. We can also create multiple files in a library.

2. Create a header file for the library

3. Compile library files.

 gcc -c lib_mylib.c -o lib_mylib.o

4. Create static library. This step is to bundle multiple object files in one static library (see ar for details). The output of this step is static library.

 ar rcs lib_mylib.a lib_mylib.o

5. Now our static library is ready to use. At this point we could just copy lib_hello_static.a somewhere else to use it. For demo purposes, let us keep the library in the current directory.

Let us create a driver program that uses above created static library.
1. Create a C file with main function

 gcc -c lib_mylib.c -o lib_mylib.o

 ar rcs lib_mylib.a lib_mylib.o

gcc -c driver.c -o driver.o

gcc -o driver driver.o -L. -l_mylib

./driver 
fun() called from a static library

2. Compile the driver program.

Given two variables, x and y, swap two variables without using a third variable.

Method 1 (Using Arithmetic Operators)
The idea is to get sum in one of the two given numbers. The numbers can then be swapped using the sum and subtraction from sum.

include <stdio.h>

int main()

{

  int x = 10, y = 5;

  // Code to swap 'x' and 'y'

  x = x + y;  // x now becomes 15

  y = x - y;  // y becomes 10

  x = x - y;  // x becomes 5

  printf("After Swapping: x = %d, y = %d", x, y);

  return 0;

}

Output:

After Swapping: x = 5, y = 10

Multiplication and division can also be used for swapping.

include <stdio.h>

int main()

{

  int x = 10, y = 5;

  // Code to swap 'x' and 'y'

  x = x * y;  // x now becomes 50

  y = x / y;  // y becomes 10

  x = x / y;  // x becomes 5

  printf("After Swapping: x = %d, y = %d", x, y);

  return 0;

}

Output:

After Swapping: x = 5, y = 10

Method 2 (Using Bitwise XOR)
The bitwise XOR operator can be used to swap two variables. The XOR of two numbers x and y returns a number which has all the bits as 1 wherever bits of x and y differ. For example XOR of 10 (In Binary 1010) and 5 (In Binary 0101) is 1111 and XOR of 7 (0111) and 5 (0101) is (0010).

#include <stdio.h>

int main()

{

  int x = 10, y = 5;

  // Code to swap 'x' (1010) and 'y' (0101)

  x = x ^ y;  // x now becomes 15 (1111)

  y = x ^ y;  // y becomes 10 (1010)

  x = x ^ y;  // x becomes 5 (0101)

  printf("After Swapping: x = %d, y = %d", x, y);

  return 0;

}

Output:

After Swapping: x = 5, y = 10

Problems with above methods
1) The multiplication and division based approach doesn’ work if one of the numbers is 0 as the product becomes 0 irrespective of the other number.

2) Both Arithmetic solutions may cause arithmetic overflow. If x and y are too large, addition and multiplication may go out of integer range.

3) When we use pointers to variable and make a function swap, all of the above methods fail when both pointers point to the same variable. Let’s take a look what will happen in this case if both are pointing to the same variable.

// Bitwise XOR based method
x = x ^ x; // x becomes 0
x = x ^ x; // x remains 0
x = x ^ x; // x remains 0

// Arithmetic based method
x = x + x; // x becomes 2x
x = x – x; // x becomes x

x = x – x; // x becomes 0

Let us see the following program.

#include <stdio.h>

void swap(int *xp, int *yp)

{

    *xp = *xp ^ *yp;

    *yp = *xp ^ *yp;

    *xp = *xp ^ *yp;

}

int main()

{

  int x = 10;

  swap(&x, &x);

  printf("After swap(&x, &x): x = %d", x);

  return 0;

}

Output:

After swap(&x, &x): x = 0

Swapping a variable with itself may needed in many standard algorithms. For example see this implementation of QuickSort where we may swap a variable with itself. The above problem can be avoided by putting a condition before the swapping.

#include <stdio.h>

void swap(int *xp, int *yp)

{

    if (xp == yp) // Check if the two addresses are same

      return;

    *xp = *xp + *yp;

    *yp = *xp - *yp;

    *xp = *xp - *yp;

}

int main()

{

  int x = 10;

  swap(&x, &x);

  printf("After swap(&x, &x): x = %d", x);

  return 0;

Output:

After swap(&x, &x): x = 10

A pointer is a variable that contains the address of a variable. Pointers are much used in C,

partly because they are sometimes the only way to express a computation, and partly because

they usually lead to more compact and efficient code than can be obtained in other ways.

Pointers and arrays are closely related; this chapter also explores this relationship and shows

how to exploit it.

This is certainly true when they are used carelessly, and it is easy to create pointers that point somewhere unexpected. With discipline, however, pointers can also be used to achieve clarity and simplicity. This is the aspect that we will try to illustrate.

The main change in ANSI C is to make explicit the rules about how pointers can be

manipulated, in effect mandating what good programmers already practice and good compilers

already enforce. In addition, the type void * (pointer to void) replaces char * as the proper

type for a generic pointer.

Pointers and Addresses:-

Let us begin with a simplified picture of how memory is organized. A typical machine has an

array of consecutively numbered or addressed memory cells that may be manipulated

individually or in contiguous groups. One common situation is that any byte can be a char, 4 byte cells can be treated as a short integer, and 8 adjacent bytes form a long. A

pointer is a group of cells (often two or four) that can hold an address.

So if c is a char and p is a pointer that points to it, we could represent the situation this way:

The unary operator & gives the address of an object, so the statement

p = &c;

assigns the address of c to the variable p, and p is said to “point to” c. The & operator only

applies to objects in memory: variables and array elements. It cannot be applied to expressions,

constants, or register variables.

The unary operator * is the indirection or dereferencing operator; when applied to a pointer, it

accesses the object the pointer points to. Suppose that x and y are integers and ip is a pointer

to int. This artificial sequence shows how to declare a pointer and how to use & and *:

int x = 1, y = 2, z[10];

int *ip; /* ip is a pointer to int */

ip = &x; /* ip now points to x */

y = *ip; /* y is now 1 */

*ip = 0; /* x is now 0 */

ip = &z[0]; /* ip now points to z[0] */

The declaration of x, y, and z are what we’ve seen all along.

Pointers and Arrays:-

In C, there is a strong relationship between pointers and arrays, strong enough that pointers

and arrays should be discussed simultaneously. Any operation that can be achieved by array

subscripting can also be done with pointers. The pointer version will in general be faster but, at

least to the uninitiated, somewhat harder to understand.

The declaration

int a[10];

defines an array of size 10, that is, a block of 10 consecutive objects named a[0], a[1],

…,a[9].

The notation a[i] refers to the i-th element of the array. If pa is a pointer to an integer,

declared as

int *pa;

then the assignment

pa = &a[0];

sets pa to point to element zero of a; that is, pa contains the address of a[0].

Now the assignment

x = *pa;

will copy the contents of a[0] into x.

If pa points to a particular element of an array, then by definition pa+1 points to the next

element, pa+i points i elements after pa, and pa-i points i elements before. Thus, if pa points

to a[0],

*(pa+1)

refers to the contents of a[1], pa+i is the address of a[i], and *(pa+i) is the contents of

a[i].

These remarks are true regardless of the type or size of the variables in the array a. The

meaning of “adding 1 to a pointer,” and by extension, all pointer arithmetic, is that pa+1 points

to the next object, and pa+i points to the i-th object beyond pa.

The correspondence between indexing and pointer arithmetic is very close. By definition, the

value of a variable or expression of type array is the address of element zero of the array. Thus

after the assignment

pa = &a[0];

pa and a have identical values. Since the name of an array is a synonym for the location of the

initial element, the assignment pa=&a[0] can also be written as

pa = a;

Rather more surprising, at first sight, is the fact that a reference to a[i] can also be written as

*(a+i). In evaluating a[i], C converts it to *(a+i) immediately; the two forms are

equivalent. Applying the operator & to both parts of this equivalence, it follows that &a[i] and

a+i are also identical: a+i is the address of the i-th element beyond a. As the other side of this

coin, if pa is a pointer, expressions might use it with a subscript; pa[i] is identical to *(pa+i).

In short, an array-and-index expression is equivalent to one written as a pointer and offset.

There is one difference between an array name and a pointer that must be kept in mind. A

pointer is a variable, so pa=a and pa++ are legal. But an array name is not a variable;

constructions like a=pa and a++ are illegal.

When an array name is passed to a function, what is passed is the location of the initial

element. Within the called function, this argument is a local variable, and so an array name

parameter is a pointer, that is, a variable containing an address. We can use this fact to write

another version of strlen, which computes the length of a string.

/* strlen: return length of string s */

int strlen(char *s)

{

int n;

for (n = 0; *s != ”, s++)

n++;

return n;

}

Since s is a pointer, incrementing it is perfectly legal; s++ has no effect on the character string

in the function that called strlen, but merely increments strlen’s private copy of the pointer.

That means that calls like

strlen(“hello, world”); /* string constant */

strlen(array); /* char array[100]; */

strlen(ptr); /* char *ptr; */

all work.

RCS file: amit.c,v
Working file: amit.c
head: 1.21
branch:
locks: strict
amitdalal: 1.21
access list:
symbolic names:
keyword substitution: kv
total revisions: 21; selected revisions: 21
description:
added function of copy from user
printk the no of byte writen successfully for one quantum
—————————-
revision 1.21 locked by: amitdalal;
date: 2013/08/01 00:53:49; author: amitdalal; state: Exp; lines: +71 -5
define function for ioctl to control the operation
use cmd SCULL_IOCRESET,SCULL_IOCSQUANTUM,SCULL_IOCQSET,SCULL_IOCDATA,SCULL_IOCDEVICE
USE capability cmd for cheking capability
—————————-
revision 1.20
date: 2013/07/28 00:07:05; author: amitdalal; state: Exp; lines: +21 -7
create proc_read_entry function inside sculldev loop
define read_proc out side the sculldev loop
—————————-
revision 1.19
date: 2013/07/26 19:26:10; author: amitdalal; state: Exp; lines: +4 -3
use spin_lock_irq before raeding
use spin_unlock_irq func. at the end off writing
—————————-
revision 1.18
date: 2013/07/26 00:33:49; author: amitdalal; state: Exp; lines: +9 -19
use wait_for_complition in read
use complete_all in write
—————————-
revision 1.17
date: 2013/07/25 23:23:36; author: amitdalal; state: Exp; lines: +9 -8
initialise sem_init again
—————————-
revision 1.16
date: 2013/07/25 23:02:12; author: amitdalal; state: Exp; lines: +33 -11
initialise two semaphore for read and write in sculldev initialisation
down semaphore in write for write
at the end up semaphore for read
down semaphore in write for read
at the end up semaphore for write
—————————-
revision 1.15
date: 2013/07/22 22:47:17; author: amitdalal; state: Exp; lines: +5 -5
initialise the semaphore init in scull_open for kernel level synchronisation
call down_interruptible in open
call up in release function
define trim function
calculate nosqs and noq agin in trim function
memset the quantum_size
to free all quantum
—————————-
revision 1.14
date: 2013/07/22 22:07:46; author: amitdalal; state: Exp; lines: +102 -40
define fpos variable for fetching file position in read
add fpos to count to calculate the nosqs and noq
—————————-
revision 1.13
date: 2013/07/17 00:08:24; author: amitdalal; state: Exp; lines: +0 -1
added some variable for write using llseek
added bpos for position update in copy from user
define bpos flag
—————————-
revision 1.12
date: 2013/07/17 00:07:11; author: amitdalal; state: Exp; lines: +0 -1
added variable bpos for position
use flag and j
—————————-
revision 1.11
date: 2013/07/17 00:02:29; author: amitdalal; state: Exp; lines: +0 -2
added some variable for reading using llseek
fix the problem related with left out of some first character
—————————-
revision 1.10
date: 2013/07/16 23:37:14; author: amitdalal; state: Exp; lines: +244 -194
give call to llseek
define function llseek
—————————-
revision 1.9
date: 2013/07/15 21:52:06; author: amitdalal; state: Exp; lines: +67 -41
added loff_t function to .c file
use f_pos for storing the value of pos
—————————-
revision 1.8
date: 2013/07/11 17:37:19; author: amitdalal; state: Exp; lines: +53 -38
modified code for write to get required no of qset
add lnoq variable
—————————-
revision 1.7
date: 2013/07/11 06:05:24; author: amitdalal; state: Exp; lines: +0 -1
add loop variable in loop for reading
remove some bug in reading loop
—————————-
revision 1.6
date: 2013/07/11 05:37:03; author: amitdalal; state: Exp; lines: +4 -4
remove some bug from write function
added loop variable to specify no of quantum in 2nd qset
—————————-
revision 1.5
date: 2013/07/11 05:18:10; author: amitdalal; state: Exp; lines: +76 -16
creating read function
use copy to user function
modifing the copy to user function
—————————-
revision 1.4
date: 2013/07/11 00:41:53; author: amitdalal; state: Exp; lines: +1 -0
debbuging problem causing kernel crash
—————————-
revision 1.3
date: 2013/07/11 00:19:58; author: amitdalal; state: Exp; lines: +11 -7
added variable loop
use while loop for creating multiple qset
—————————-
revision 1.2
date: 2013/07/11 00:00:36; author: amitdalal; state: Exp; lines: +25 -4
added the function of quantum written for 8 byte
debugging the problem related to writting of data not 8 byte
fix problem successfully related to written
—————————-
revision 1.1
date: 2013/07/10 21:22:34; author: amitdalal; state: Exp;
Initial revision
=============================================================================

RCS file: header.h,v
Working file: header.h
head: 1.10
branch:
locks: strict
amitdalal: 1.10
access list:
symbolic names:
keyword substitution: kv
total revisions: 10; selected revisions: 10
description:
added asm header .h for copy from user
—————————-
revision 1.10 locked by: amitdalal;
date: 2013/08/01 00:59:39; author: amitdalal; state: Exp; lines: +9 -3
include prototype of ioctl
define ioctl in the file operation
—————————-
revision 1.9
date: 2013/07/28 00:09:43; author: amitdalal; state: Exp; lines: +1 -0
include header file for proc
—————————-
revision 1.8
date: 2013/07/26 19:29:27; author: amitdalal; state: Exp; lines: +3 -1
initialise spinlock_t my_lock in header file
./
—————————-
revision 1.7
date: 2013/07/26 00:38:59; author: amitdalal; state: Exp; lines: +3 -3
define macro for complition in header.h
another way is to define the complition in sculldev
—————————-
revision 1.6
date: 2013/07/25 23:25:01; author: amitdalal; state: Exp; lines: +9 -3
include struct semaphore rsem and wsem in sculldev
—————————-
revision 1.5
date: 2013/07/22 22:12:52; author: amitdalal; state: Exp; lines: +3 -1
defined header file for semaphore in kernel level
define semaphore in Sculldev structure
—————————-
revision 1.4
date: 2013/07/16 23:38:48; author: amitdalal; state: Exp; lines: +7 -7
include prototype of llseek
define llseek in file operation
—————————-
revision 1.3
date: 2013/07/15 21:53:32; author: amitdalal; state: Exp; lines: +5 -2
give prototype of llseek
define it in file operation
—————————-
revision 1.2
date: 2013/07/11 17:39:26; author: amitdalal; state: Exp; lines: +5 -5
remove init and cleanup prototype
—————————-
revision 1.1
date: 2013/07/10 21:25:25; author: amitdalal; state: Exp;
Initial revision
=============================================================================

RCS file: ioctlheader.h,v
Working file: ioctlheader.h
head: 1.1
branch:
locks: strict
amitdalal: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
include all the macro for reseting,setting quantum no.
macro for setting qset no.
macro for setting data no.
macro for setting device no.
—————————-
revision 1.1 locked by: amitdalal;
date: 2013/08/01 01:01:24; author: amitdalal; state: Exp;
Initial revision
=============================================================================

RCS file: ioctlheader.h,v
Working file: ioctlheader.h
head: 1.1
branch:
locks: strict
amitdalal: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
include all the macro for reseting,setting quantum no.
macro for setting qset no.
macro for setting data no.
macro for setting device no.
—————————-
revision 1.1 locked by: amitdalal;
date: 2013/08/01 01:01:24; author: amitdalal; state: Exp;
Initial revision
=============================================================================

RCS file: amit.c,v
Working file: amit.c
head: 1.20
branch:
locks: strict
amitdalal: 1.20
access list:
symbolic names:
keyword substitution: kv
total revisions: 20; selected revisions: 20
description:
added function of copy from user
printk the no of byte writen successfully for one quantum
—————————-
revision 1.20 locked by: amitdalal;
date: 2013/07/28 00:07:05; author: amitdalal; state: Exp; lines: +21 -7
create proc_read_entry function inside sculldev loop
define read_proc out side the sculldev loop
—————————-
revision 1.19
date: 2013/07/26 19:26:10; author: amitdalal; state: Exp; lines: +4 -3
use spin_lock_irq before raeding
use spin_unlock_irq func. at the end off writing
—————————-
revision 1.18
date: 2013/07/26 00:33:49; author: amitdalal; state: Exp; lines: +9 -19
use wait_for_complition in read
use complete_all in write
—————————-
revision 1.17
date: 2013/07/25 23:23:36; author: amitdalal; state: Exp; lines: +9 -8
initialise sem_init again
—————————-
revision 1.16
date: 2013/07/25 23:02:12; author: amitdalal; state: Exp; lines: +33 -11
initialise two semaphore for read and write in sculldev initialisation
down semaphore in write for write
at the end up semaphore for read
down semaphore in write for read
at the end up semaphore for write
—————————-
revision 1.15
date: 2013/07/22 22:47:17; author: amitdalal; state: Exp; lines: +5 -5
initialise the semaphore init in scull_open for kernel level synchronisation
call down_interruptible in open
call up in release function
define trim function
calculate nosqs and noq agin in trim function
memset the quantum_size
to free all quantum
—————————-
revision 1.14
date: 2013/07/22 22:07:46; author: amitdalal; state: Exp; lines: +102 -40
define fpos variable for fetching file position in read
add fpos to count to calculate the nosqs and noq
—————————-
revision 1.13
date: 2013/07/17 00:08:24; author: amitdalal; state: Exp; lines: +0 -1
added some variable for write using llseek
added bpos for position update in copy from user
define bpos flag
—————————-
revision 1.12
date: 2013/07/17 00:07:11; author: amitdalal; state: Exp; lines: +0 -1
added variable bpos for position
use flag and j
—————————-
revision 1.11
date: 2013/07/17 00:02:29; author: amitdalal; state: Exp; lines: +0 -2
added some variable for reading using llseek
fix the problem related with left out of some first character
—————————-
revision 1.10
date: 2013/07/16 23:37:14; author: amitdalal; state: Exp; lines: +244 -194
give call to llseek
define function llseek
—————————-
revision 1.9
date: 2013/07/15 21:52:06; author: amitdalal; state: Exp; lines: +67 -41
added loff_t function to .c file
use f_pos for storing the value of pos
—————————-
revision 1.8
date: 2013/07/11 17:37:19; author: amitdalal; state: Exp; lines: +53 -38
modified code for write to get required no of qset
add lnoq variable
—————————-
revision 1.7
date: 2013/07/11 06:05:24; author: amitdalal; state: Exp; lines: +0 -1
add loop variable in loop for reading
remove some bug in reading loop
—————————-
revision 1.6
date: 2013/07/11 05:37:03; author: amitdalal; state: Exp; lines: +4 -4
remove some bug from write function
added loop variable to specify no of quantum in 2nd qset
—————————-
revision 1.5
date: 2013/07/11 05:18:10; author: amitdalal; state: Exp; lines: +76 -16
creating read function
use copy to user function
modifing the copy to user function
—————————-
revision 1.4
date: 2013/07/11 00:41:53; author: amitdalal; state: Exp; lines: +1 -0
debbuging problem causing kernel crash
—————————-
revision 1.3
date: 2013/07/11 00:19:58; author: amitdalal; state: Exp; lines: +11 -7
added variable loop
use while loop for creating multiple qset
—————————-
revision 1.2
date: 2013/07/11 00:00:36; author: amitdalal; state: Exp; lines: +25 -4
added the function of quantum written for 8 byte
debugging the problem related to writting of data not 8 byte
fix problem successfully related to written
—————————-
revision 1.1
date: 2013/07/10 21:22:34; author: amitdalal; state: Exp;
Initial revision
=============================================================================

RCS file: header.h,v
Working file: header.h
head: 1.9
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 9; selected revisions: 9
description:
added asm header .h for copy from user
—————————-
revision 1.9
date: 2013/07/28 00:09:43; author: amitdalal; state: Exp; lines: +1 -0
include header file for proc
—————————-
revision 1.8
date: 2013/07/26 19:29:27; author: amitdalal; state: Exp; lines: +3 -1
initialise spinlock_t my_lock in header file
./
—————————-
revision 1.7
date: 2013/07/26 00:38:59; author: amitdalal; state: Exp; lines: +3 -3
define macro for complition in header.h
another way is to define the complition in sculldev
—————————-
revision 1.6
date: 2013/07/25 23:25:01; author: amitdalal; state: Exp; lines: +9 -3
include struct semaphore rsem and wsem in sculldev
—————————-
revision 1.5
date: 2013/07/22 22:12:52; author: amitdalal; state: Exp; lines: +3 -1
defined header file for semaphore in kernel level
define semaphore in Sculldev structure
—————————-
revision 1.4
date: 2013/07/16 23:38:48; author: amitdalal; state: Exp; lines: +7 -7
include prototype of llseek
define llseek in file operation
—————————-
revision 1.3
date: 2013/07/15 21:53:32; author: amitdalal; state: Exp; lines: +5 -2
give prototype of llseek
define it in file operation
—————————-
revision 1.2
date: 2013/07/11 17:39:26; author: amitdalal; state: Exp; lines: +5 -5
remove init and cleanup prototype
—————————-
revision 1.1
date: 2013/07/10 21:25:25; author: amitdalal; state: Exp;
Initial revision
=============================================================================

RCS file: app11.c,v
Working file: app11.c
head: 1.1
branch:
locks: strict
amitdalal: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
define set_sem_val function
define semaphore_p and semaphore_v
done this for all 5 applicatin
—————————-
revision 1.1 locked by: amitdalal;
date: 2013/07/25 23:29:38; author: amitdalal; state: Exp;
Initial revision
=============================================================================

RCS file: amit.c,v
Working file: amit.c
head: 1.18
branch:
locks: strict
amitdalal: 1.18
access list:
symbolic names:
keyword substitution: kv
total revisions: 18; selected revisions: 18
description:
added function of copy from user
printk the no of byte writen successfully for one quantum
—————————-
revision 1.18 locked by: amitdalal;
date: 2013/07/26 00:33:49; author: amitdalal; state: Exp; lines: +9 -19
use wait_for_complition in read
use complete_all in write
—————————-
revision 1.17
date: 2013/07/25 23:23:36; author: amitdalal; state: Exp; lines: +9 -8
initialise sem_init again
—————————-
revision 1.16
date: 2013/07/25 23:02:12; author: amitdalal; state: Exp; lines: +33 -11
initialise two semaphore for read and write in sculldev initialisation
down semaphore in write for write
at the end up semaphore for read
down semaphore in write for read
at the end up semaphore for write
—————————-
revision 1.15
date: 2013/07/22 22:47:17; author: amitdalal; state: Exp; lines: +5 -5
initialise the semaphore init in scull_open for kernel level synchronisation
call down_interruptible in open
call up in release function
define trim function
calculate nosqs and noq agin in trim function
memset the quantum_size
to free all quantum
—————————-
revision 1.14
date: 2013/07/22 22:07:46; author: amitdalal; state: Exp; lines: +102 -40
define fpos variable for fetching file position in read
add fpos to count to calculate the nosqs and noq
—————————-
revision 1.13
date: 2013/07/17 00:08:24; author: amitdalal; state: Exp; lines: +0 -1
added some variable for write using llseek
added bpos for position update in copy from user
define bpos flag
—————————-
revision 1.12
date: 2013/07/17 00:07:11; author: amitdalal; state: Exp; lines: +0 -1
added variable bpos for position
use flag and j
—————————-
revision 1.11
date: 2013/07/17 00:02:29; author: amitdalal; state: Exp; lines: +0 -2
added some variable for reading using llseek
fix the problem related with left out of some first character
—————————-
revision 1.10
date: 2013/07/16 23:37:14; author: amitdalal; state: Exp; lines: +244 -194
give call to llseek
define function llseek
—————————-
revision 1.9
date: 2013/07/15 21:52:06; author: amitdalal; state: Exp; lines: +67 -41
added loff_t function to .c file
use f_pos for storing the value of pos
—————————-
revision 1.8
date: 2013/07/11 17:37:19; author: amitdalal; state: Exp; lines: +53 -38
modified code for write to get required no of qset
add lnoq variable
—————————-
revision 1.7
date: 2013/07/11 06:05:24; author: amitdalal; state: Exp; lines: +0 -1
add loop variable in loop for reading
remove some bug in reading loop
—————————-
revision 1.6
date: 2013/07/11 05:37:03; author: amitdalal; state: Exp; lines: +4 -4
remove some bug from write function
added loop variable to specify no of quantum in 2nd qset
—————————-
revision 1.5
date: 2013/07/11 05:18:10; author: amitdalal; state: Exp; lines: +76 -16
creating read function
use copy to user function
modifing the copy to user function
—————————-
revision 1.4
date: 2013/07/11 00:41:53; author: amitdalal; state: Exp; lines: +1 -0
debbuging problem causing kernel crash
—————————-
revision 1.3
date: 2013/07/11 00:19:58; author: amitdalal; state: Exp; lines: +11 -7
added variable loop
use while loop for creating multiple qset
—————————-
revision 1.2
date: 2013/07/11 00:00:36; author: amitdalal; state: Exp; lines: +25 -4
added the function of quantum written for 8 byte
debugging the problem related to writting of data not 8 byte
fix problem successfully related to written
—————————-
revision 1.1
date: 2013/07/10 21:22:34; author: amitdalal; state: Exp;
Initial revision
=============================================================================

RCS file: dd1,v
Working file: dd1
head: 1.5
branch:
locks: strict
amitdalal: 1.5
access list:
symbolic names:
keyword substitution: kv
total revisions: 5; selected revisions: 5
description:
adding compilation command for reading in script
gcc
./app1
—————————-
revision 1.5 locked by: amitdalal;
date: 2013/07/25 23:26:50; author: amitdalal; state: Exp; lines: +16 -2
run the 5 application simutanously
—————————-
revision 1.4
date: 2013/07/18 21:17:28; author: amitdalal; state: Exp; lines: +1 -1
added -lpthread for compilation
—————————-
revision 1.3
date: 2013/07/15 21:55:17; author: amitdalal; state: Exp; lines: +4 -3
add unlink node
—————————-
revision 1.2
date: 2013/07/11 06:00:23; author: amitdalal; state: Exp; lines: +2 -2
make another node for reading
—————————-
revision 1.1
date: 2013/07/11 05:16:48; author: amitdalal; state: Exp;
Initial revision
=============================================================================

RCS file: header.h,v
Working file: header.h
head: 1.7
branch:
locks: strict
amitdalal: 1.7
access list:
symbolic names:
keyword substitution: kv
total revisions: 7; selected revisions: 7
description:
added asm header .h for copy from user
—————————-
revision 1.7 locked by: amitdalal;
date: 2013/07/26 00:38:59; author: amitdalal; state: Exp; lines: +3 -3
define macro for complition in header.h
another way is to define the complition in sculldev
—————————-
revision 1.6
date: 2013/07/25 23:25:01; author: amitdalal; state: Exp; lines: +9 -3
include struct semaphore rsem and wsem in sculldev
—————————-
revision 1.5
date: 2013/07/22 22:12:52; author: amitdalal; state: Exp; lines: +3 -1
defined header file for semaphore in kernel level
define semaphore in Sculldev structure
—————————-
revision 1.4
date: 2013/07/16 23:38:48; author: amitdalal; state: Exp; lines: +7 -7
include prototype of llseek
define llseek in file operation
—————————-
revision 1.3
date: 2013/07/15 21:53:32; author: amitdalal; state: Exp; lines: +5 -2
give prototype of llseek
define it in file operation
—————————-
revision 1.2
date: 2013/07/11 17:39:26; author: amitdalal; state: Exp; lines: +5 -5
remove init and cleanup prototype
—————————-
revision 1.1
date: 2013/07/10 21:25:25; author: amitdalal; state: Exp;
Initial revision
=============================================================================

RCS file: app11.c,v
Working file: app11.c
head: 1.1
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
use mutex for inter thread communication
initialise mutex in main app11 function
use mutex_lock
use mutex_unlock for one application app11
—————————-
revision 1.1
date: 2013/07/22 22:16:09; author: amitdalal; state: Exp;
Initial revision
=============================================================================

RCS file: amit.c,v
Working file: amit.c
head: 1.15
branch:
locks: strict
amitdalal: 1.15
access list:
symbolic names:
keyword substitution: kv
total revisions: 15; selected revisions: 15
description:
added function of copy from user
printk the no of byte writen successfully for one quantum
—————————-
revision 1.15 locked by: amitdalal;
date: 2013/07/22 22:47:17; author: amitdalal; state: Exp; lines: +5 -5
initialise the semaphore init in scull_open for kernel level synchronisation
call down_interruptible in open
call up in release function
define trim function
calculate nosqs and noq agin in trim function
memset the quantum_size
to free all quantum
—————————-
revision 1.14
date: 2013/07/22 22:07:46; author: amitdalal; state: Exp; lines: +102 -40
define fpos variable for fetching file position in read
add fpos to count to calculate the nosqs and noq
—————————-
revision 1.13
date: 2013/07/17 00:08:24; author: amitdalal; state: Exp; lines: +0 -1
added some variable for write using llseek
added bpos for position update in copy from user
define bpos flag
—————————-
revision 1.12
date: 2013/07/17 00:07:11; author: amitdalal; state: Exp; lines: +0 -1
added variable bpos for position
use flag and j
—————————-
revision 1.11
date: 2013/07/17 00:02:29; author: amitdalal; state: Exp; lines: +0 -2
added some variable for reading using llseek
fix the problem related with left out of some first character
—————————-
revision 1.10
date: 2013/07/16 23:37:14; author: amitdalal; state: Exp; lines: +244 -194
give call to llseek
define function llseek
—————————-
revision 1.9
date: 2013/07/15 21:52:06; author: amitdalal; state: Exp; lines: +67 -41
added loff_t function to .c file
use f_pos for storing the value of pos
—————————-
revision 1.8
date: 2013/07/11 17:37:19; author: amitdalal; state: Exp; lines: +53 -38
modified code for write to get required no of qset
add lnoq variable
—————————-
revision 1.7
date: 2013/07/11 06:05:24; author: amitdalal; state: Exp; lines: +0 -1
add loop variable in loop for reading
remove some bug in reading loop
—————————-
revision 1.6
date: 2013/07/11 05:37:03; author: amitdalal; state: Exp; lines: +4 -4
remove some bug from write function
added loop variable to specify no of quantum in 2nd qset
—————————-
revision 1.5
date: 2013/07/11 05:18:10; author: amitdalal; state: Exp; lines: +76 -16
creating read function
use copy to user function
modifing the copy to user function
—————————-
revision 1.4
date: 2013/07/11 00:41:53; author: amitdalal; state: Exp; lines: +1 -0
debbuging problem causing kernel crash
—————————-
revision 1.3
date: 2013/07/11 00:19:58; author: amitdalal; state: Exp; lines: +11 -7
added variable loop
use while loop for creating multiple qset
—————————-
revision 1.2
date: 2013/07/11 00:00:36; author: amitdalal; state: Exp; lines: +25 -4
added the function of quantum written for 8 byte
debugging the problem related to writting of data not 8 byte
fix problem successfully related to written
—————————-
revision 1.1
date: 2013/07/10 21:22:34; author: amitdalal; state: Exp;
Initial revision
=============================================================================

RCS file: dd1,v
Working file: dd1
head: 1.9
branch:
locks: strict
amitdalal: 1.9
access list:
symbolic names:
keyword substitution: kv
total revisions: 5; selected revisions: 5
description:
adding compilation command for reading in script
gcc
./app1
—————————-
revision 1.9 locked by: amitdalal;
date: 2013/07/21 22:56:36; author: amitdalal; state: Exp; lines: +8 -0
added gcc command for 5 application
added executable command for all the 5 application
—————————-
revision 1.8
date: 2013/07/18 21:17:28; author: amitdalal; state: Exp; lines: +1 -1
added -lpthread for compilation
—————————-
revision 1.7
date: 2013/07/15 21:55:17; author: amitdalal; state: Exp; lines: +4 -3
add unlink node
—————————-
revision 1.6
date: 2013/07/11 06:00:23; author: amitdalal; state: Exp; lines: +2 -2
make another node for reading
—————————-
revision 1.5
date: 2013/07/11 05:16:48; author: amitdalal; state: Exp;
Initial revision
=============================================================================
RCS file: dd1,v
Working file: dd1
head: 1.4
branch:
locks: strict
amitdalal: 1.4
access list:
symbolic names:
keyword substitution: kv
total revisions: 4; selected revisions: 4
description:
adding compilation command for reading in script
gcc
./app1
—————————-
revision 1.4 locked by: amitdalal;
date: 2013/07/19 21:17:28; author: amitdalal; state: Exp; lines: +1 -1
added -lpthread for compilation
—————————-
revision 1.3
date: 2013/07/15 21:55:17; author: amitdalal; state: Exp; lines: +4 -3
add unlink node
—————————-
revision 1.2
date: 2013/07/11 06:00:23; author: amitdalal; state: Exp; lines: +2 -2
make another node for reading
—————————-
revision 1.1
date: 2013/07/11 05:16:48; author: amitdalal; state: Exp;
Initial revision
=============================================================================
:
RCS file: header.h,v
Working file: header.h
head: 1.5
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 5; selected revisions: 5
description:
added asm header .h for copy from user
—————————-
revision 1.5
date: 2013/07/22 22:12:52; author: amitdalal; state: Exp; lines: +3 -1
defined header file for semaphore in kernel level
define semaphore in Sculldev structure
—————————-
revision 1.4
date: 2013/07/16 23:38:48; author: amitdalal; state: Exp; lines: +7 -7
include prototype of llseek
define llseek in file operation
—————————-
revision 1.3
date: 2013/07/15 21:53:32; author: amitdalal; state: Exp; lines: +5 -2
give prototype of llseek
define it in file operation
—————————-
revision 1.2
date: 2013/07/11 17:39:26; author: amitdalal; state: Exp; lines: +5 -5
remove init and cleanup prototype
—————————-
revision 1.1
date: 2013/07/10 21:25:25; author: amitdalal; state: Exp;
Initial revision
=============================================================================

RCS file: app.c,v
Working file: app.c
head: 1.9
branch:
locks: strict
amitdalal: 1.9
access list:
symbolic names:
keyword substitution: kv
total revisions: 9; selected revisions: 9
description:
extended the message in buff
—————————-
revision 1.9 locked by: amitdalal;
date: 2013/07/21 22:38:57; author: amitdalal; state: Exp; lines: +127 -73
include some header file for ipc semaphore and thread semaphore
give the prototype of set sem_value
give prototype for semaphore_p and semaphore_v
defined union semun structure
created ipc semaphore for ist application
call the function set_sem_value
call the function semaphore _p
call the function semaphore_v at te end of main finction
defined semaphor_p,semaphore_v and set_sem_val function
same step are done for 5 application except calling set_value function
—————————-
revision 1.8
date: 2013/07/18 21:16:18; author: amitdalal; state: Exp; lines: +0 -1
added pthread join function
added pthread exit
—————————-
revision 1.7
date: 2013/07/18 21:08:19; author: amitdalal; state: Exp; lines: +94 -41
define the function for open
4 thread created
define the function for write
lssek function after write
define function for read
define function for close
—————————-
revision 1.6
date: 2013/07/17 21:37:34; author: amitdalal; state: Exp; lines: +8 -5
added variable len0,count0 for lseek after write
added lseek after write
again use the write function to append
—————————-
revision 1.5
date: 2013/07/17 00:11:50; author: amitdalal; state: Exp; lines: +0 -1
added variable
use lseek
update write
printk offset value
—————————-
revision 1.4
date: 2013/07/16 23:40:05; author: amitdalal; state: Exp; lines: +71 -68
include header file for lseek
set the offset
printf the value of offset
—————————-
revision 1.3
date: 2013/07/15 21:56:21; author: amitdalal; state: Exp; lines: +52 -15
added lseek for f_pos
printf the newpos
—————————-
revision 1.2
date: 2013/07/11 00:32:38; author: amitdalal; state: Exp; lines: +1 -1
extended the message to check whether my multiple qset is working or not for above 64 byte
—————————-
revision 1.1
date: 2013/07/11 00:04:48; author: amitdalal; state: Exp;
Initial revision
=============================================================================
RCS file: dd1,v
Working file: dd1
head: 1.5
branch:
locks: strict
amitdalal: 1.5
access list:
symbolic names:
keyword substitution: kv
total revisions: 5; selected revisions: 5
description:
adding compilation command for reading in script
gcc
./app1
—————————-
revision 1.5 locked by: amitdalal;
date: 2013/07/21 22:56:36; author: amitdalal; state: Exp; lines: +8 -0
added gcc command for 5 application
added executable command for all the 5 application
—————————-
revision 1.4
date: 2013/07/18 21:17:28; author: amitdalal; state: Exp; lines: +1 -1
added -lpthread for compilation
—————————-
revision 1.3
date: 2013/07/15 21:55:17; author: amitdalal; state: Exp; lines: +4 -3
add unlink node
—————————-
revision 1.2
date: 2013/07/11 06:00:23; author: amitdalal; state: Exp; lines: +2 -2
make another node for reading
—————————-
revision 1.1
date: 2013/07/11 05:16:48; author: amitdalal; state: Exp;
Initial revision
=============================================================================

I have been working on character device driver since last two to three weeks and here I am
giving you the concept and idea I am using in character driver till now.

Let us start with the basic idea about character driver before moving on what is happening in architecture which help me to create my device driver.
DEVICE DRIVER -> These are loadable kernel modules that can be inserted in kernel at the run time and they provide a well defined interface for hardware to respond to a specific application code that want to communicate with the hardware . user at user level gives some specific code through application and the role of these device driver is to make these command work for hardware.

CHARACTER DRIVER -> Character driver is driver that access the device character by character i.e a stream of bytes as in files.

MODULE -> It is piece of code that is used for communication b/w hardware and software

Device driver concept divided into two basic part.
1. user level -> where your application reside
2. kernel level -> where your modules and drivers reside
now question arise how link is created b/w user level and kernel level.
NODE -> node created the link b/w user level and kernel level
USER SPACE(APPLICATION)
|

KERNEL SPACE(MODULES AND DRIVERS)

|
HARDWARE

There are few structures which were defind in kernel and user space through which we can defined functionality of our device driver
KERNEL DEFINED STRUCTURE :
1. STRUCT FILE
2. STRUCT Inode
3. Cdev
USER DEFINED STRUCTURE:
1. Struct Sculldev
2. Struct Scull_qset
3. Struct file operations

Scull -> Scull is a memory space which is allocated in machine memory to your device. in scull we have two vital structure know as struct Sculldev and struct Scull_qset. The former one is the starting point of scull as well as contains data about all the scullqset present in your scull in a way it contains metadata. its member are as fallow-
1. *scull_qset
2. Scull qset_size
3. data_size
4. quantum_size
5. device_size.
6. struct cdev.
struct Sculldev //user defined structure Sculldev
{
struct Scull_qset *scull_qset; //pointing to 1st quantum set(Scull_qset structure)
int quantum_size; //current quantum size
int qset_size; //current array size
int data_size; //amount of data stored here
int device_size;
int open_count;
struct cdev var_dev; //cdev structure defined in cdev header file
}*sculldev; //used for pointing Sculldev

Scull_qset is a structure which store data or information. it mainly has two member:
1. *next -> pointer to next scull_qset
2. **data -> double pointer to your data, means first it will point to an array of pointer known as qset , contains quantum where actually our data is kept.
struct Scull_qset
{
struct Scull_qset *next;
void **data;
};

Struct file operations -> It generally defines the behavior of our device. It is used here to map the user level system calls to programmer defined system call.
Some defined system call:
1. OPEN
2. CLOSE(RELEASE)
3. WRITE
4. READ
5. LLSEEK
struct file_operations fops=
{
open:scull_open,
read:scull_read,
write:scull_write,
llseek:scull_llseek,
release:scull_release

};

Now comes kernel level structures into picture.
STRUCT INODE -> as we all know that in linux everything is file either it is a text file, some kind of code or any device with each and every file there is an associated inode structure , here we will mainly concentrate and concerned about which is particularly represents our device. “inode” is the only way through which we can or its better to say our application can interact with our device.
main member are:
1. i_cev ->which points to your struct cdev. pointer to file operations.
2.
Struct file -> Members are:
1. *f_pos :- which takes the account of the cursor in your file. pointer to file operations
2. *private data :- which will help us to do mapping from your user level to kernal level as its stores the address of your SCULL so we can access all the data which we have stored in quantum part of scullqset from user level.

Struct Cdev—> It mainly has three member:
1. owner :- which specifies about its owner name
2. pointer to file operation
3. dev which contains major and minor no.

void Sculldev_initialisation(void)
{
int a,lv;
for(lv=0;lv Major no. is a number which is given to each and every device driver we have in our machine
Minor no -> Minor no. is the number which represents your the device associated with that particular device driver.

majorno=MAJOR(dev); //extract major no.from device number
minorno=MINOR(dev); //extract minor no.from device number

This is all about the architecture now lets have look on the operations or working.

STEPS USED IN IMPLIMENTATION OF CHARACTER DRIVER

1. Insmod -> which will load our module, module is a source code which is loaded on demand.
insmod ./modules/amit.ko

2. Registration -> register our device driver and device so that DD will get a major number and device gets its own minor number.
ret=alloc_chrdev_region(&dev,minorno,nod,DRIVER_NAME); //when we are registering one device (for dynamic allocation)

3.Allocation -> Allocate space to Scull in machine memory.
sculldev=kmalloc(sizeof(struct Sculldev)*nod , GFP_KERNEL); //allocate memory to Sculldev

4.Initialize Scull –> cdev_init— create link between struct inode and struct cdev… define owner.. cdev_add make attribute of device available to our kernel.
void Sculldev_initialisation(void)
{
int a,lv;
for(lv=0;lv flash data if present in the memory space which is assigned to scull

7.Open -> define open system call.
int scull_open(struct inode *inodep, struct file *filep)
{

struct Sculldev* pdev;
printk(KERN_ALERT”BEGIN:open SUCCESSFULLY :%s\n”,__func__);

pdev=(struct Sculldev *)container_of(inodep->i_cdev, struct Sculldev, var_dev); // map the memeory allocated to Sculldev to VFS which is going to return pointer(A convenience macro that may be used to obtain a pointer to a structure from a pointer to some other structure contained within it.)

filep->private_data =pdev; //all information stored in pdev pointer conatining address

if((filep->f_flags && O_ACCMODE) == O_WRONLY)
{

printk(KERN_ALERT”FILE OPEN\n”);
scull_trim(pdev);
}

printk(KERN_ALERT”END:open close SUCCESSFULLY: %s\n”,__func__);
return 0;
}

8. Write ->before doing that allocate space to Scullqset then to qset and at last to quantum now we can write data to our quantum, LSEEK if needed.
ssize_t scull_write(struct file *filep,const char __user *buff,size_t count, loff_t *f_pos)
{
struct Sculldev *pdev;
struct Scull_qset *qset;
int noq,nosqs,i,j,ret=0,loop=0; //noq=no.of quantum,nosqs=no. of scull_qset,
int nobpq,noctw,nocsw,flag=0,bpos=0; //nocsw=no. of character successfully write
noq=nosqs=nobpq=noctw=nocsw=0;
pdev=filep->private_data; //fetch the device

printk(KERN_ALERT”BEGIN:write open SUCCESSFULLY: %s\n”,__func__);
if(!pdev)
{
printk(“no private data”);
}

nosqs=count/(quantum_size*qset_size); //finding no. of scull_qset required
if(count % (quantum_size*qset_size))
nosqs++;
pdev->scull_qset=create_scull_qset(nosqs); //creating scull_qset(Sculldev *pdev pointing towards *scull_qset)
if(!pdev->scull_qset)
{
printk(“no scull_qset found\n”);
}
noq=count/quantum_size;
if(count%quantum_size)
noq++;

qset=pdev->scull_qset;
create_qset(qset,nosqs); //creating _qset
create_quantum(qset,noq); //creating _quantum
nobpq=quantum_size;
nocsw=0;
noctw=count;
int offset=filep->f_pos;
printk(KERN_ALERT”offset=%d\n”,(int)filep->f_pos); //data write in quantum

while(nosqs)
{
if(noq>quantum_size)
{
loop=quantum_size;
}
else
{
loop=noq;
}
if(flag==0)
{
if(offset>quantum_size)
{
j=offset/quantum_size;
bpos=offset%quantum_size;
nobpq=quantum_size-bpos;
}
else
{
j=0;
nobpq=quantum_size-offset;
bpos=offset;
}
flag=1;
}
else
{
j=0;
loop=noq;
bpos=0;
}
for(i=j;idata[i]+bpos,buff+nocsw,nobpq); //copy data from user space
printk(KERN_ALERT”quantum=%d->write=%s\n”,i,(char *)qset->data[i]+bpos); //data write in quantum
nocsw=nocsw+(nobpq-ret);
noctw=noctw-(nobpq-ret);
if(noctw>quantum_size)
{
nobpq=quantum_size;
}
else
{
nobpq=noctw;
}
printk(KERN_ALERT”no. of byte successfully write=%d\n”,nocsw);
printk(KERN_ALERT”no. of byte not write=%d\n”,ret);
bpos=0;
}
nosqs–;
qset=qset->next;
noq=noq-quantum_size;
}
printk(KERN_ALERT”no.of qset=%d\n”,loop);

printk(KERN_ALERT”END:write close SUCCESSFULLY : %s\n”,__func__);
return count-ret;
}

9. Read -> read whatever you have written to quantum.
ssize_t scull_read(struct file *filep,char __user *buff,size_t count, loff_t *f_pos)

ret=copy_to_user(buff+nocsr,qset->data[i]+bpos,nobpq); //copy data from user space
10. Release-> de-allocate all the space, unregister your device and DD, remove your module.
int scull_release(struct inode *inodep, struct file *filep)
{
printk(KERN_ALERT”BEGIN:OPEN SUCCESSFULLY release: %s\n”,__func__);
printk(KERN_ALERT”END:close SUCCESSFULLY release: %s\n”,__func__);
return 0;
}

For unregistering :

static void cleanup(void)
{
int lv;
printk(KERN_ALERT “BEGIN: %s\n”,__func__);
printk(KERN_ALERT”\ngood bye\n”);
for(lv=0;lv make
For making node -> mknod node c 249 0

TO remove the driver -> rmmod amit

HERE I AM GIVING YOU THE IMPLIMENTATION PROCEDURE TO CLEARIFY THE ALL STEP:-

Initialization of driver -> Mapping of system calls from application to the driver -> open call -> Mapping of memory on to the device (including trim function) -> Write call -> Read call -> Seek call ->use of multi threaded application.

We have used command “insmod” to call the initialization macro i.e. module_init() which will insert the driver into the list of modules & “rmmod” to call the cleanup macro i.e. module_exit() which will remove the driver from the list.

Driver starts with the registration using alloc_chrdev_region(). This registration (using alloc_chrdev_region()) is done so as to get the major number dynamically for the driver. Correspondingly a minor number is generated for the first device.
We can also use register_chrdev() to register the driver if we want to assign the user defined major number.

After registration we got a 32 bit number stored in “dev” which is of “dev_t” type. First 12 bits will give major number by using macro “MAJOR” & remaining 20 bits will give the minor number by using macro “MINOR”.

After getting the major & minor number, now its time to initialize the SCULL i.e. Simple character utility for loading localities. SCULL is a char driver that acts on the memory area as though it was a device. This SCULL is defined by a structure “Sculldev” contains blocks of memory called scullqsets which are also called as items and each item contains qsets which are nothing but array of pointers pointing to specific locations known as quantums. The scullqset or item can handle data maximum upto the data equal to product of qset_size and quantum size. Further each quantum can store maximum of bytes equal to quantum_size defined by the developer. We can calculate the number of scullqsets and number of quantums required for storing given number of bytes. One thing which is very important that these “items” or we can say that “scullqsets” should be linked like “link list” so as to store the data in quantums of different scullqsets.

After initializing the structure Sculldev, now we have to initialize the structure C_dev which will give the information of our device i.e. Owner of the device, Major & Minor numbers, operations that our device can perform etc. After this its time to map the system calls to the corresponding functions defined in the driver.

As the mapping is done so now from the application end we will call the open system call which will call our defined function in driver. In normal routine open call creates a stream and after handing over of the stream this call terminates. For our driver we have written our own routines. In our open function we have used a macro “container_of” to map the memory allocated for scull from RAM to the device & along with the link of “Structure inode” with “Structure C_dev & SCULL. This mapping will return the starting address of the SCULL which we will store into the “private data” of the “Structure file”. When ever & where ever if we want to access the sculldev we will fetch the private data. After sending the address of Sculldev we will call the trim function.

If we want to write on to the device, we have to check whether the device is having something onto its memory or not. If we found anything in quantums, we first trim the data nothing but flushing out the previously written bytes.

After trimming we will call write from the application. This write system call will call the write function which we have in our driver as we have already mapped all the operations to be performed by the applications in “Structure file_operations”. Writing here means getting the data from the user buffer & writing it on the quantums present in the SCULL i.e. Memory of device. In the starting of write function we will fetch the private data so as to get the address of SCULL. For writing we will use “Copy_from_user()”. Before writing we will calculate the number of items (scullqsets) to be created along with the number of quantums. Now we want to read what we have written earlier in the quantums. For this we will call the read function. This means reading the data from the quantums & passing it to the user buffer which we will receive in our application. For this we will use “Copy_to_user()”.

amit.c

RCS file: amit.c,v
Working file: amit.c
head: 1.13
branch:
locks: strict
amitdalal: 1.13
access list:
symbolic names:
keyword substitution: kv
total revisions: 13; selected revisions: 13
description:
added function of copy from user
printk the no of byte writen successfully for one quantum
—————————-
revision 1.13 locked by: amitdalal;
date: 2013/07/17 00:08:24; author: amitdalal; state: Exp; lines: +0 -1
added some variable for write using llseek
added bpos for position update in copy from user
define bpos flag
—————————-
revision 1.12
date: 2013/07/17 00:07:11; author: amitdalal; state: Exp; lines: +0 -1
added variable bpos for position
use flag and j
—————————-
revision 1.11
date: 2013/07/17 00:02:29; author: amitdalal; state: Exp; lines: +0 -2
added some variable for reading using llseek
fix the problem related with left out of some first character
—————————-
revision 1.10
date: 2013/07/16 23:37:14; author: amitdalal; state: Exp; lines: +244 -194
give call to llseek
define function llseek
—————————-
revision 1.9
date: 2013/07/15 21:52:06; author: amitdalal; state: Exp; lines: +67 -41
added loff_t function to .c file
use f_pos for storing the value of pos
—————————-
revision 1.8
date: 2013/07/11 17:37:19; author: amitdalal; state: Exp; lines: +53 -38
modified code for write to get required no of qset
add lnoq variable
—————————-
revision 1.7
date: 2013/07/11 06:05:24; author: amitdalal; state: Exp; lines: +0 -1
add loop variable in loop for reading
remove some bug in reading loop
—————————-
revision 1.6
date: 2013/07/11 05:37:03; author: amitdalal; state: Exp; lines: +4 -4
remove some bug from write function
added loop variable to specify no of quantum in 2nd qset
—————————-
revision 1.5
date: 2013/07/11 05:18:10; author: amitdalal; state: Exp; lines: +76 -16
creating read function
use copy to user function
modifing the copy to user function
—————————-
revision 1.4
date: 2013/07/11 00:41:53; author: amitdalal; state: Exp; lines: +1 -0
debbuging problem causing kernel crash
—————————-
revision 1.3
date: 2013/07/11 00:19:58; author: amitdalal; state: Exp; lines: +11 -7
added variable loop
use while loop for creating multiple qset
—————————-
revision 1.2
date: 2013/07/11 00:00:36; author: amitdalal; state: Exp; lines: +25 -4
added the function of quantum written for 8 byte
debugging the problem related to writting of data not 8 byte
fix problem successfully related to written
—————————-
revision 1.1
date: 2013/07/10 21:22:34; author: amitdalal; state: Exp;
Initial revision
=============================================================================

app.c

RCS file: app.c,v
Working file: app.c
head: 1.8
branch:
locks: strict
amitdalal: 1.8
access list:
symbolic names:
keyword substitution: kv
total revisions: 8; selected revisions: 8
description:
extended the message in buff
—————————-
revision 1.8 locked by: amitdalal;
date: 2013/07/19 21:16:18; author: amitdalal; state: Exp; lines: +0 -1
added pthread join function
added pthread exit
—————————-
revision 1.7
date: 2013/07/19 21:08:19; author: amitdalal; state: Exp; lines: +94 -41
define the function for open
4 thread created
define the function for write
lssek function after write
define function for read
define function for close
—————————-
revision 1.6
date: 2013/07/18 21:37:34; author: amitdalal; state: Exp; lines: +8 -5
added variable len0,count0 for lseek after write
added lseek after write
again use the write function to append
—————————-
revision 1.5
date: 2013/07/17 00:11:50; author: amitdalal; state: Exp; lines: +0 -1
added variable
use lseek
update write
printk offset value
—————————-
revision 1.4
date: 2013/07/16 23:40:05; author: amitdalal; state: Exp; lines: +71 -68
include header file for lseek
set the offset
printf the value of offset
—————————-
revision 1.3
date: 2013/07/15 21:56:21; author: amitdalal; state: Exp; lines: +52 -15
added lseek for f_pos
printf the newpos
—————————-
revision 1.2
date: 2013/07/11 00:32:38; author: amitdalal; state: Exp; lines: +1 -1
extended the message to check whether my multiple qset is working or not for above 64 byte
—————————-
revision 1.1
date: 2013/07/11 00:04:48; author: amitdalal; state: Exp;
Initial revision
=============================================================================

script

RCS file: dd1,v
Working file: dd1
head: 1.4
branch:
locks: strict
amitdalal: 1.4
access list:
symbolic names:
keyword substitution: kv
total revisions: 4; selected revisions: 4
description:
adding compilation command for reading in script
gcc
./app1
—————————-
revision 1.4 locked by: amitdalal;
date: 2013/07/19 21:17:28; author: amitdalal; state: Exp; lines: +1 -1
added -lpthread for compilation
—————————-
revision 1.3
date: 2013/07/15 21:55:17; author: amitdalal; state: Exp; lines: +4 -3
add unlink node
—————————-
revision 1.2
date: 2013/07/11 06:00:23; author: amitdalal; state: Exp; lines: +2 -2
make another node for reading
—————————-
revision 1.1
date: 2013/07/11 05:16:48; author: amitdalal; state: Exp;
Initial revision
=============================================================================

rcs file

amit.c
RCS file: amit.c,v
Working file: amit.c
head: 1.13
branch:
locks: strict
amitdalal: 1.13
access list:
symbolic names:
keyword substitution: kv
total revisions: 13; selected revisions: 13
description:
added function of copy from user
printk the no of byte writen successfully for one quantum
—————————-
revision 1.13 locked by: amitdalal;
date: 2013/07/17 00:08:24; author: amitdalal; state: Exp; lines: +0 -1
added some variable for write using llseek
added bpos for position update in copy from user
define bpos flag
—————————-
revision 1.12
date: 2013/07/17 00:07:11; author: amitdalal; state: Exp; lines: +0 -1
added variable bpos for position
use flag and j
—————————-
revision 1.11
date: 2013/07/17 00:02:29; author: amitdalal; state: Exp; lines: +0 -2
added some variable for reading using llseek
fix the problem related with left out of some first character
—————————-
revision 1.10
date: 2013/07/16 23:37:14; author: amitdalal; state: Exp; lines: +244 -194
give call to llseek
define function llseek
—————————-
revision 1.9
date: 2013/07/15 21:52:06; author: amitdalal; state: Exp; lines: +67 -41
added loff_t function to .c file
use f_pos for storing the value of pos
—————————-
revision 1.8
date: 2013/07/11 17:37:19; author: amitdalal; state: Exp; lines: +53 -38
modified code for write to get required no of qset
add lnoq variable
—————————-
revision 1.7
date: 2013/07/11 06:05:24; author: amitdalal; state: Exp; lines: +0 -1
add loop variable in loop for reading
remove some bug in reading loop
—————————-
revision 1.6
date: 2013/07/11 05:37:03; author: amitdalal; state: Exp; lines: +4 -4
remove some bug from write function
added loop variable to specify no of quantum in 2nd qset
—————————-
revision 1.5
date: 2013/07/11 05:18:10; author: amitdalal; state: Exp; lines: +76 -16
creating read function
use copy to user function
modifing the copy to user function
—————————-
revision 1.4
date: 2013/07/11 00:41:53; author: amitdalal; state: Exp; lines: +1 -0
debbuging problem causing kernel crash
—————————-
revision 1.3
date: 2013/07/11 00:19:58; author: amitdalal; state: Exp; lines: +11 -7
added variable loop
use while loop for creating multiple qset
—————————-
revision 1.2
date: 2013/07/11 00:00:36; author: amitdalal; state: Exp; lines: +25 -4
added the function of quantum written for 8 byte
debugging the problem related to writting of data not 8 byte
fix problem successfully related to written
—————————-
revision 1.1
date: 2013/07/10 21:22:34; author: amitdalal; state: Exp;
Initial revision
=============================================================================
header.h

RCS file: header.h,v
Working file: header.h
head: 1.4
branch:
locks: strict
amitdalal: 1.4
access list:
symbolic names:
keyword substitution: kv
total revisions: 4; selected revisions: 4
description:
added asm header .h for copy from user
—————————-
revision 1.4 locked by: amitdalal;
date: 2013/07/16 23:38:48; author: amitdalal; state: Exp; lines: +7 -7
include prototype of llseek
define llseek in file operation
—————————-
revision 1.3
date: 2013/07/15 21:53:32; author: amitdalal; state: Exp; lines: +5 -2
give prototype of llseek
define it in file operation
—————————-
revision 1.2
date: 2013/07/11 17:39:26; author: amitdalal; state: Exp; lines: +5 -5
remove init and cleanup prototype
—————————-
revision 1.1
date: 2013/07/10 21:25:25; author: amitdalal; state: Exp;
Initial revision
=============================================================================

app.c

RCS file: app.c,v
Working file: app.c
head: 1.5
branch:
locks: strict
amitdalal: 1.5
access list:
symbolic names:
keyword substitution: kv
total revisions: 5; selected revisions: 5
description:
extended the message in buff
—————————-
revision 1.5 locked by: amitdalal;
date: 2013/07/17 00:11:50; author: amitdalal; state: Exp; lines: +0 -1
added variable
use lseek
update write
printk offset value
—————————-
revision 1.4
date: 2013/07/16 23:40:05; author: amitdalal; state: Exp; lines: +71 -68
include header file for lseek
set the offset
printf the value of offset
—————————-
revision 1.3
date: 2013/07/15 21:56:21; author: amitdalal; state: Exp; lines: +52 -15
added lseek for f_pos
printf the newpos
—————————-
revision 1.2
date: 2013/07/11 00:32:38; author: amitdalal; state: Exp; lines: +1 -1
extended the message to check whether my multiple qset is working or not for above 64 byte
—————————-
revision 1.1
date: 2013/07/11 00:04:48; author: amitdalal; state: Exp;
Initial revision
=============================================================================