MODULE_LICENSE(“GPL”);
MODULE_AUTHOR(“KERNEL_CODE”);

#define DEBUG
#define NAME “char_dev”
#define NODE 5
#define SCULL_MAJOR 0
#define SCULL_MINOR 0
#define QUANTUM 8
#define SIZE 0
#define QSET 8
#define DEV_SIZE 1024
#define DEVICE_NAME “char_dev”
#define CLASS_NAME “scull”

static int scull_minor = SCULL_MINOR;
static int scull_major = SCULL_MAJOR;
static struct class* scull_class = NULL;
static struct device* scull_device = NULL;
int size = SIZE;
int qset = QSET;
int quantum = QUANTUM;

struct Scull_qset{
struct Scull_qset *next;
void **data1;
};
dev_t dev;

struct Scull_dev{
struct Scull_qset *data;
int quantum;
int qset;
int device_size;
int data_size;
struct cdev cdev;
};

struct Scull_dev *scull_dev;
const struct file_operations fops=
{};

struct inode *finode;
struct file *ffile;

/***********************************************************************************/
/* sysfs entry for 1st operation *//*we can pass the arguments we need*/
static ssize_t sys_entry1(struct device* dev, struct device_attribute* attr, const char* buf, size_t count)
{
#ifdef DEBUG
printk(KERN_INFO ” string from user is%s\n”,buf);
#endif
return count;
}

/* Declare the sysfs entries. The macros create instances of dev_attr_fifo and dev_attr_reset */
static DEVICE_ATTR(entry, S_IWUSR, NULL, sys_entry1);
/***********************************************************************************/

static int __init hello_world(void){

int retval;

retval = alloc_chrdev_region(&dev,scull_minor,NODE,DEVICE_NAME);
scull_minor = MINOR(dev);
scull_major = MAJOR(dev);
scull_dev = kmalloc(NODE*sizeof(struct Scull_dev),GFP_KERNEL);
memset(scull_dev,”,sizeof(struct Scull_dev));

/* use a “virtual” device class. */
scull_class = class_create(THIS_MODULE, CLASS_NAME);
printk(KERN_DEBUG”register device class ‘%s’\n”, CLASS_NAME);
if (!scull_class) {
printk(KERN_DEBUG”register device class ‘%s’\n”, CLASS_NAME);
goto OUT;
}

/* With a class, the easiest way to instantiate a device is to call device_create() */
scull_device = device_create(scull_class, NULL, MKDEV(scull_major, 0), NULL, CLASS_NAME “_” DEVICE_NAME);
if (!scull_device) {
printk(KERN_DEBUG”register device class ‘%s’\n”, DEVICE_NAME);
goto OUT;
}

/* dev_attr_entry come from the DEVICE_ATTR(…) earlier */
retval = device_create_file(scull_device, &dev_attr_entry);
if (retval cdev,&fops);
scull_dev->quantum = quantum;
scull_dev->qset = qset;
scull_dev->device_size= size;
scull_dev->cdev.owner = THIS_MODULE;
scull_dev->cdev.ops = &fops;
retval = cdev_add(&scull_dev->cdev,dev, NODE);
if(retvalcdev);
kfree(scull_dev);
device_remove_file(scull_device, &dev_attr_entry);
device_destroy(scull_class, MKDEV(scull_major, 0));
class_unregister(scull_class);
class_destroy(scull_class);
#ifdef DEBUG
printk(KERN_INFO”cha_device unregistration from fun %s\n”,__func__);
printk(KERN_INFO”BYE BYE \n”);
#endif
}

module_init(hello_world);
module_exit(hello_exit);

GRUB features

The primary requirement for GRUB is that it be compliant with the Multiboot Specification, which is described in Section “Motivation” in The Multiboot Specification.
The other goals, listed in approximate order of importance, are:
 Basic functions must be straightforward for end-users.
 Rich functionality to support kernel experts and designers.
 Backward compatibility for booting FreeBSD, NetBSD, OpenBSD, and Linux. Proprietary kernels (such as DOS, Windows NT, and OS/2) are supported via a chain-loading function.

Types of Serial Communication:

1)Synchronous: In Master/Slave interface, both master and slave are driven with same clock(master clock). So this interface is termed as synchronous.
2)Asynchronous: In Point to Point or peer interfaces clock need not to be synchronized between DTE(Data Terminal Equipment) and DCE(Data Communication Equipment). Most of the peer interfaces are asynchronous.

Why Serial???

As every Embedded System has to communicate with external world, it could be some peripheral device or another system for debugging purpose. And Serial interface serves as the best due to many reasons.

1)Small number of pins needed (2 or 3).
2)Availability of different protocols for different interfaces.
3)Good for long distance communication.
4)High Speed.

Protocols:

There are many different serial protocols for different interfaces. Most popular ones are,
RS232, SPI, I2C CAN. Depending upon the application we can select the most appropriate one.
RS232 is commonly used for debugging purpose. Max possible speed is 115.2 kbps.
SPI(Serial Peripheral Interface) is as its name suggest used to interface peripherals. It is a Mater/Slave Synchronous protocol.
I2C(Inter IC) is commonly used to interface, on board peripherals(IC). It is a multi master synchronous protocol.
CAN is used for Inter MCU(micro controller unit) communication in a System. For example it is used in vehicle where number of MCUs are used to serve different purposes.

Then I increased the size of Stack to 256 MB  (using system call setrlimit()) now i am getting an error i.e Bus error (core dumped)…

I googled for this error but still i am not getting what actually caused this???

How is this different from Segmentation fault????

I have been working upon Device Driver (Character Driver, to be specific) since last 20 days.Before start working, First of all I needed to know what really a device driver is? As we all know it is the kernel what is directly going to interact with the Hardware and if our application need to access the hardware we need a driver(Specific one for a class of devices)for that in kernel space. As the name suggest a Device Driver is a LKM(Loadable Kernel Module) which drives(runs) our device.Drivers are of two types, Static and Dynamic. One i am going to develop will be dynamic i.e it will be removed from kernel when not needed any more. The good thing about a Moduler kernel is a Module can be inserted and removed from the running kernel(using kernel utilities insmod and rmmod respectively). There are three types of devices i.e Character devices like printers, Block devices like Mass storage devices and Network devices like USB modem etc. Now a Character driver is a driver developed to handle character devices.
Now lets explain the basic arch. of a character driver. Memory of our system is divided in to two parts User space and kernel space. Our applications runs in the user space and our driver runs in kernel space. An application cant see anything in kernel space.Driver is just like a black box for the application developer. So if the application need to access the kernel space, it need a fifo in the VFS(Virtual File System) layer. We create this for the specific device using mknod. In kernel space a driver is identified by its unique 12bit major number and a device is identified by its unique 20bit minor number. This 32bit unique number is called dev id(device id). This 32bit no is obtained for a device using a kernel MACRO i.e alloc_chrdev_region(). This registration is to be done right after inserting our module in to the kernel and it should also be unregistered before removing the module.
There are four most important structures, knowing about those was very much needed. First one is struct cdev. This structure is the representation of a character device in the kernel. This one have a lot of hardware specific information of the device. its most important members are dev(for dev id),owner(owner of the device, the module itself) and *fops (pointer to the struct file_operations). Second one in struct file_operations which is a collection of function pointers, each of the function is routine for performing a specific operation over the device like read, write ,open, close etc. Another one is struct inode(for the device file). We all know everything in linux is treated as a file, some are regular files and some are special files. A character device is treated as a special file in our system. Attributes of a file are stored in the structure struct inode and struct inode i am talking about have attributes of that special character device file. Fourth one is struct file. struct file is a structure which contains the attributes of a stream. This stream is a stream created between our app and node in vfs, when we give an open call from app.
I have allocated some memory in the kernel space of my RAM in form of SCULL(Simple Character Utility for Loading Localities), which i am treating as a device. This memory is variable as i will be performing write and read, it will be allocated and deallocated accordingly. Starting node of this memory is ScullDev which will be loaded with the lot of info about the device like device_size, data_size, quantum_size, qset_size, write_count and the most important an object of struct cdev. We need to initialize and add this cdev object as our device in the kernel using two MACROS cdev_init() and cdev_add(). cdev_init will initialize our object for the set of operations and cdev_add will add this device in to the device table.
After all this, my device is ready to be worked upon i.e open,write,read,close. For this it was required to map my driver routines to the routines called by system as when a call is given from app my routines should run in the driver. This mapping is to be done in struct file_operations by giving the addresses of my_routines to corresponding function pointers in fops. In open i fetched the address of my ScullDev for the perticular cdev and stored it in private_data field of a system generated structure struct file pointed by *filep in open for the future use of this address in write and read.
Now i am able to write data to the multiple quantums, multiple scullqset in trunc as well as append mode. I am able to read from the same as well. lseek is also done, and i am testing my driver for multithreaded apps.

#include<stdio.h>
#include<stdlib.h>

int main()
{
void *ptr;

char i;

ptr = malloc(sizeof(int ) * 5);

for(i = 0; i<(sizeof(int) * 5); i++)
{
*(int *)(ptr + i) = i;
printf(” ptr + %d = %p\t %d\n”, i, (ptr + i – 1), *(int *)(ptr + i – 1));
}
return 0;
}

1) child process shares the parent’s process context???

or

2)child is provided with a new copy of parent’s process context???

when i am creating a file manually like using command vim filename….size of the file is one greater than the no of bytes(charcters) in the file…while checking what exactly that last byte is, i found that is EOLine (10 in decimal)..

But if i creat a file using c library function open and write, the size is exactly equal to the no of bytes in file….Why is it so?????