server_add.sin_family = AF_INET;
server_add.sin_port=htons(7770);
server_add.sin_addr.s_addr = inet_addr(“127.0.0.1″);
if(setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&true,sizeof(int))==-1)
{
sockfd = socket(AF_INET,SOCK_STREAM,0);
if(sockfd==-1)
{
printf(“fail in openning socket”);
}
}

printf(“sockfd =%d\n”,sockfd);

bret = bind(sockfd,(struct sockaddr *)&server_add,sizeof(struct sockaddr));
printf(“bind return %d\n”,bret);
if(bret==-1)
{
printf(“error in binding”);
}

listen(sockfd,3);

len = sizeof(client_add);
//printf(“len %d\n”,*len);
aret = accept(sockfd,(struct sockaddr *)&client_add,&len);
printf(“accept return %d\n”,aret);
read(aret,ch,5);
printf(“SERVER:%s\n”,ch);
return 0;
}

1.15
date 2014.05.11.08.48.49; author root; state Exp;
branches;
next 1.14;

1.14
date 2014.05.10.07.23.56; author root; state Exp;
branches;
next 1.13;

1.13
date 2014.05.10.07.17.59; author root; state Exp;
branches;
next 1.12;

1.12
date 2014.05.09.10.22.15; author root; state Exp;
branches;
next 1.11;

1.11
date 2014.05.09.10.20.37; author root; state Exp;
branches;
next 1.10;

1.10
date 2014.05.09.07.45.13; author root; state Exp;
branches;
next 1.9;

1.9
date 2014.05.09.07.43.59; author root; state Exp;
branches;
next 1.8;

1.8
date 2014.05.09.07.39.00; author root; state Exp;
branches;
next 1.7;

1.7
date 2014.05.09.07.36.42; author root; state Exp;
branches;
next 1.6;

1.6
date 2014.05.09.07.35.17; author root; state Exp;
branches;
next 1.5;

1.5
date 2014.05.09.07.21.24; author root; state Exp;
branches;
next 1.4;

1.4
date 2014.05.08.11.42.32; author root; state Exp;
branches;
next 1.3;

1.3
date 2014.05.08.07.09.50; author root; state Exp;
branches;
next 1.2;

1.2
date 2014.05.06.11.48.01; author root; state Exp;
branches;
next 1.1;

1.1
date 2014.05.06.11.22.20; author root; state Exp;
branches;
next ;

desc
@initialization done.
@

1.15
log
@aloocated memory using kmalloc.
@
text
@#include”header.h”
#include”declration.c”
//#include”file_op.c”
unsigned int major_no,minor_no,nod;
dev_t dev;
struct sculldev *scull_dev;
module_param(nod,uint,S_IRUGO);
static int __init init_func(void)
{ int ret;
major_no= MAJORNO;
minor_no= MINORNO;
//nod= NOD;
//struct file_operations fops;
printk(KERN_INFO “we are in kernel”);
ret = alloc_chrdev_region(&dev,minor_no,nod,”poonam”);
if(ret<0)
{
printk(KERN_ERR"failed\n");
}
major_no=MAJOR(dev);
minor_no=MINOR(dev);
printk(KERN_INFO"sucessful registration major no =%d\n",major_no);
printk(KERN_INFO"sucessful registration minor no =%d\n",minor_no);
printk(KERN_INFO"nod is =%d\n",nod);
scull_dev = kmalloc((sizeof( struct sculldev)*nod), GFP_KERNEL);
if(!scull_dev)
{
printk(KERN_ERR"kmalloc failure\n");
return -1;
}

printk(KERN_INFO"kmalloc successfull\n");

return 0;
}

module_init(init_func);
@

1.14
log
@*** empty log message ***
@
text
@d6 1
d15 1
a15 1
ret = alloc_chrdev_region(&dev,minor_no,nod,"arjun");
d25 9
@

1.13
log
@add module_param macro
before initilaization function defination
@
text
@d6 1
a6 1
module_param(nod,unsigned int,S_IRUGO);
@

1.12
log
@*** empty log message ***
@
text
@d6 1
d11 1
a11 1
nod= NOD;
d23 1
@

1.11
log
@*** empty log message ***
@
text
@d11 1
a11 1
struct file_operations fops;
d18 2
a19 2
major_no=MAJORNO(dev);
minor_no=MINORNO(dev);
@

1.10
log
@*** empty log message ***
@
text
@d6 3
a8 3
static int init_func(void)
int ret;
{ major_no= MAJORNO;
@

1.9
log
@*** empty log message ***
@
text
@d18 1
a18 1
majro_no=MAJORNO(dev);
@

1.8
log
@*** empty log message ***
@
text
@d7 1
a10 1
int ret;
@

1.7
log
@*** empty log message ***
@
text
@d7 2
a8 2
{ major_no= MAJOR_NO;
minor_no= MINOR_NO;
d18 2
a19 2
majro_no=MAJOR_NO(dev);
minor_no=MINOR_NO(dev);
@

1.6
log
@*** empty log message ***
@
text
@d9 1
a9 1
NOD=nod;
@

1.5
log
@using alloc function
@
text
@d5 1
@

1.4
log
@used file operation variable.
@
text
@d2 1
d4 1
d6 3
a8 1
{
d12 1
a12 1
ret = register_chrdev(0,"mychardevice",&fops);
d17 5
a21 1
printk(KERN_INFO"sucessful registration %d\n",ret);
@

1.3
log
@included file operations in init function.
@
text
@d2 1
a2 1
#include"file_op.c"
d6 1
@

1.2
log
@register my char device.
@
text
@d7 6
a12 1
ret = register(0,"mychardevice",&fops);
@

1.1
log
@Initial revision
@
text
@d2 1
d4 2
a5 1
{
d7 1
@

New modules can use symbols exported by your module, and you can stack new modules on top of other modules. Module stacking is implemented in the mainstream kernel sources as well: the msdos filesystem relies on symbols exported by the fat module, and each input USB device module stacks on the usbcore and input modules.

Module stacking is useful in complex projects. If a new abstraction is implemented in the form of a device driver, it might offer a plug for hardware-specific implementations. For example, the video-for-linux set of drivers is split into a generic module that exports symbols used by lower-level device drivers for specific hardware. According to your setup, you load the generic video module and the specific module for your installed hardware. Support for parallel ports and the wide variety of attachable devices is handled in the same way, as is the USB kernel subsystem. Stacking in the parallel port subsystem is shown in Figure 2-2; the arrows show the communications between the modules and with the kernel programming interface.

When using stacked modules, it is helpful to be aware of the modprobe utility. As we described earlier, modprobe functions in much the same way as insmod, but it also loads any other modules that are required by the module you want to load. Thus, one modprobe command can sometimes replace several invocations of insmod (although you’ll still need insmod when loading your own modules from the current directory, because modprobe looks only in the standard installed module directories).

Using stacking to split modules into multiple layers can help reduce development time by simplifying each layer. This is similar to the separation between mechanism and policy that we discussed in Chapter 1.

The Linux kernel header files provide a convenient way to manage the visibility of your symbols, thus reducing namespace pollution (filling the namespace with names that may conflict with those defined elsewhere in the kernel) and promoting proper information hiding. If your module needs to export symbols for other modules to use, the following macros should be used.

EXPORT_SYMBOL(name);
EXPORT_SYMBOL_GPL(name);

Either of the above macros makes the given symbol available outside the module. The _GPL version makes the symbol available to GPL-licensed modules only. Symbols must be exported in the global part of the module’s file, outside of any function, because the macros expand to the declaration of a special-purpose variable that is expected to be accessible globally. This variable is stored in a special part of the module executible (an “ELF section”) that is used by the kernel at load time to find the variables exported by the module.

15

printk(KERN_INFO”begin=%s\n”,__func__);
for(i=0;inext=NULL;
lscullqset->data=NULL;
}
else
{
new = (struct ScullQset *)kmalloc(sizeof(struct ScullQset),GFP_KERNEL);
new->next=NULL;
new->data=NULL;
temp->next=new;
temp=temp->next;
}

#include”header.h”
#include”declration.c”
struct ScullQset *create_scullqset(int nosqset)
{
struct ScullQset *lscullqset,*temp,*new;
int i,flag=1;
lscullqset=NULL;
//int i;

printk(KERN_INFO”begin=%s\n”,__func__);
for(i=0;inext=NULL;
lscullqset->data=NULL;
}
else
{
new = (struct ScullQset *)kmalloc(sizeof(struct ScullQset),GFP_KERNEL);
new->next=NULL;
new->data=NULL;
temp->next=new;
temp=temp->next;
}

1.   rcs -i filename

this creates a rcs file with name filenamec,v.

2. ci filename

3 . co -l filename

this locks the previous version of file and allow you to do further changes into it.

1.2
date 2014.03.25.05.06.08; author poonam; state Exp;
branches;
next 1.1;

1.1
date 2014.03.25.02.12.49; author poonam; state Exp;
branches;
next ;

desc
@implemented server with three requesting client and three processing client bt result is not perfect for each requesting client.
@

1.2
log
@used switch to run different processing clients.
@
text
@#include”header.h”
int main()
{
int i,pipe1,pipe2,pipe3,pipe4,data_r1,data_r2,data_r3,data_add,data_sub,data_mul,plus[2],plus_r,plus_w,minus[2],minus_r,minus_w,mul[2],mul_r,mul_w;
int pid1,pid2,pid3,pid4,pid5,pid6,ch;
int fd_com_req[2], fd_com_res[2],fd_com_preq[2],fd_com_pres[2];
char a[4],b[4],c[4],d[4],e[4],f[4],g[4],h[4];
int buf_client1_r[3], buf_client2_r[3], buf_client3_r[3];
pipe1=pipe(fd_com_req);
pipe2=pipe(fd_com_res);
pipe3=pipe(fd_com_preq);
pipe4=pipe(fd_com_pres);
sprintf(a,”%d”,fd_com_req[1]);
sprintf(b,”%d”,fd_com_req[0]);
sprintf(c,”%d”,fd_com_res[1]);
sprintf(d,”%d”,fd_com_res[0]);
sprintf(e,”%d”,fd_com_preq[1]);
sprintf(f,”%d”,fd_com_preq[0]);
sprintf(g,”%d”,fd_com_pres[1]);
sprintf(h,”%d”,fd_com_pres[0]);
printf(“this is server\n”);
pid1=fork();
if(pid1!=0)
{
data_r1=read(fd_com_req[0],buf_client1_r,12);
for(i=0;i<3;i++)
printf("client1[%d]=%d\n",i,buf_client1_r[i]);
pid2=fork();
if(pid2!=0)
{
data_r2=read(fd_com_req[0],buf_client2_r,12);
for(i=0;i<3;i++)
printf("client2[%d]=%d\n",i,buf_client2_r[i]);
pid3=fork();
if(pid3!=0)
{
data_r3=read(fd_com_req[0],buf_client3_r,12);
for(i=0;i<3;i++)
printf("client3[%d]=%d\n",i,buf_client3_r[i]);
int *server_buf[3] = {(int*) (buf_client1_r+0), (int*)(buf_client2_r+0),(int*)(buf_client3_r+0)};
for(i=0;i<3;i++)
{
printf("server buf %d \n",*((int*)server_buf[i]));
ch = *((int*)server_buf[i]);
switch(ch)
{
case 43: printf("add \n");
pid4=fork();
if(pid4!=0)
{
plus_r = read(fd_com_pres[0],plus,8);
printf("plus result is =%d\n",plus[1]);
plus_w = write(fd_com_res[1],plus,8);
}
else
{

data_add = write(fd_com_preq[1],buf_client1_r,12);
execl("./add","add",f,g,NULL);
}
break;

case 45: pid5=fork();
if(pid5!=0)
{
minus_r = read(fd_com_pres[0],minus,8);
printf("minus result is =%d\n",minus[1]);
minus_w = write(fd_com_res[1],minus,8);
}
else
{

data_sub = write(fd_com_preq[1],buf_client2_r,12);
execl("./sub","sub",f,g,NULL);
}
break;
case 42: pid6=fork();
if(pid6!=0)
{
mul_r = read(fd_com_pres[0],mul,8);
printf("mul result is =%d\n",mul[1]);
mul_w = write(fd_com_res[1],mul,8);
}
else
{

data_mul = write(fd_com_preq[1],buf_client3_r,12);
execl("./mul","mul",f,g,NULL);
}
break;
}
/* else
{

data_sub = write(fd_com_preq[1],buf_client2_r,12);
execl("./sub","sub",f,g,NULL);
}

}
else
{

data_add = write(fd_com_preq[1],buf_client1_r,12);
execl("./add","add",f,g,NULL);
}*/
}
}

else
{

execl("./cl3","client3",a,d,NULL);
}
}
else
{
execl("./cl2","client2",a,d,NULL);
}

}
else
{
execl("./cl1","client1",a,d,NULL);
}
}

@

1.1
log
@Initial revision
@
text
@d5 1
a5 1
int pid1,pid2,pid3,pid4,pid5,pid6;
d40 47
a86 22
//printf("clients req are \n");
pid4=fork();
if(pid4!=0)
{
plus_r = read(fd_com_pres[0],plus,8);
printf("plus result is =%d\n",plus[1]);
plus_w = write(fd_com_res[1],plus,8);
pid5=fork();
if(pid5!=0)
{
minus_r = read(fd_com_pres[0],minus,8);
printf("minus result is =%d\n",minus[1]);
minus_w = write(fd_com_res[1],minus,8);
pid6=fork();
if(pid6!=0)
{
mul_r = read(fd_com_pres[0],mul,8);
printf("mul result is =%d\n",mul[1]);
mul_w = write(fd_com_res[1],mul,8);
}
else
{
d90 2
a91 1
}
d93 1
a93 1
else
d106 2
a107 1
}
d109 1
@