EmbLogic » Ziaulhaquea356

Implementation of Register and Unregister in kernel

Ziaulhaquea356 — Thu, 26 Jun 2014 07:51:15 +0000

……………………………HEADER………………………………..

head 1.1;
access;
symbols;
locks; strict;
comment @ * @;

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

desc
@The test of register and unregister on kernels
@

……………………….DEFAULT…………………………..

head 1.2;
access;
symbols;
locks; strict;
comment @ * @;

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

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

desc
@The define is using
@

1.2
log
@chrdev is change
@
text

……………………………………DECLERATION…………………………………..

head 1.1;
access;
symbols;
locks; strict;
comment @ * @;

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

desc
@The declear is extern majorno.
@

1.1
log
@Initial revision
@

………………………………………….INITIALIZATION……………………………

head 1.1;
access;
symbols;
locks; strict;
comment @ * @;

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

desc
@This is initialization
@

1.1
log
@Initial revision
@
text

………………………………………….CLEANUP…………………………………………

head 1.1;
access;
symbols;
locks; strict;
comment @ * @;

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

desc
@This is cleanup.
@

1.1
log
@Initial revision
@

………………………………………….EDIT……………………………………..

head 1.1;
access;
symbols;
locks
root:1.1; strict;
comment @# @;

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

desc
@The all file include chrdev
@

1.1
log
@Initial revision
@

Character Device Driver

Ziaulhaquea356 — Mon, 23 Jun 2014 11:02:47 +0000

?The kernel offers several subroutines or functions in user space, which allow the end user application programmer to interact with the hardware. Usually, in UNIX or Linux systems, this dialogue is performed through functions or subroutines in order to read and write files. The reason for this is that in Unix devices are seen, from the point of view of the user, as files.

?On the other hand, in kernel space Linux also offers several functions or subroutines to perform the low level interactions directly with the hardware, and allow the transfer of information from kernel to user space.

?Usually, for each function in user space (allowing the use of devices or files), there exists an equivalent in kernel space (allowing the transfer of information from the kernel to the user and vice-versa). ?Scull is implemented on virtual disk having 8 register set. Application accesses the device through Kernel entry points available at user level. Any amount of data can be read or written to scull depending on device size on character by character basis.

Various operations can be performed on the device. Device can be opened in append mode where user can write and read from any position. In read mode , any data can be read from the device from any position .In write mode, any data can be written to the device from beginning , device will be treated as fresh device. Proc file system is used for debugging driver. Ioctl is implemented for changing device parameters . All we need to do is to pass the specification of device from the application. Synchronization Technique – Semaphore,Kernel Mutex , Blocking i/o , Completion , Poll, Spin-lock , Sequential locks,Big Kernel lock is used for multi-threaded application to avoid synchronization problem. Application is delayed before accessing scull using Kernel Timers. Kernel Timers along with Blocking i/o are used for delaying the application to access to device while the device is getting ready.

simple print at kernel

Ziaulhaquea356 — Sat, 21 Jun 2014 09:28:44 +0000

head 1.1;
access;
symbols;
locks
root:1.1; strict;
comment @ * @;

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

desc
@print on kernel.
@

1.1
log
@Initial revision
@

create socket programme using client and server

Ziaulhaquea356 — Thu, 19 Jun 2014 13:02:25 +0000

CLIENT:-

head 1.1;
access;
symbols;
locks
root:1.1; strict;
comment @ * @;

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

desc
@creat reqclient for socket.
@

1.1
log
@Initial revision
@
text
@#include”header.c”
int main()
{
char data1[3]={5,4,’+’};
char sum;
int len,server_fd,count;
struct sockaddr_in client_addr;
client_addr.sin_family=AF_INET;
client_addr.sin_port=htons(2224);
client_addr.sin_addr.s_addr=inet_addr(“127.0.0.1″);
/*struct data data1;
data1.a=2;
data1.b=4;
data1.opr=’+’;*/
int client_fd=socket(AF_INET,SOCK_STREAM,0);
if(client_fd<0)
{
perror(“\n socket is failure”);
exit(-1);
}
int fd=connect(client_fd,(struct sockaddr *)&client_addr,sizeof(struct sockaddr_in));
if(fd<0)
{
perror(“\n connect is failure”);
exit(-1);
}
len=sizeof(struct data);
count=write(client_fd,&data1,3);
printf(“no.of bytes writtern %d\n”,count);
read(client_fd,&sum,1);
printf(“sum= %d\n”,sum);
return 0;

}
@

SERVER:-

locks
root:1.1; strict;
comment @ * @;

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

desc
@server for socket impl.
@

1.1
log
@Initial revision
@
text
@#include”header.c”
int main()
{
char buff[3];
socklen_t len;
len=sizeof(struct sockaddr_in);
struct data data1;
int server_fd,server_fd1,true=1,ret,count,count1;
char sum;
struct sockaddr_in server_addr,client_addr,reqclient_addr,server_addr1,client_addr1;
server_addr.sin_family=AF_INET;
server_addr.sin_port=htons(2224);
server_addr.sin_addr.s_addr=inet_addr(“127.0.0.1″);
server_fd=socket(AF_INET,SOCK_STREAM,0);
server_fd1=socket(AF_INET,SOCK_STREAM,0);
if(setsockopt(server_fd,SOL_SOCKET,SO_REUSEADDR,&true,sizeof(int))==-1)
{
perror(“\n setsockopt is failure”);
exit(-1);
}
if(setsockopt(server_fd1,SOL_SOCKET,SO_REUSEADDR,&true,sizeof(int))==-1)
{
perror(“\n setsockopt is failure”);
exit(-1);
}

ret=bind(server_fd,(const struct sockaddr *)&server_addr,sizeof(struct sockaddr_in));
if(ret<0)
{
perror(“\n bind is failure”);
exit(-1);
}
printf(“gfhgkjj,hkh,”);
ret=listen(server_fd,5);
if(ret<0)
{
perror(“\n listen is failure”);
exit(-1);
}

int fd=accept(server_fd,( struct sockaddr *)&client_addr,&len);
if(fd<0)
{
perror(” accept is failure\n”);
exit(-1);
}

// len=sizeof(struct data);
count=read(fd,buff,3);
printf(“VALUE OF 1ST VARIABLE OF BUFF IN SERVER —>>[%d]\n”,buff[0]);
printf(“VALUE OF 2nd VARIABLE OF BUFF IN SERVER —>>[%d]\n”,buff[1]);
printf(“VALUE OF 3rd VARIABLE OF BUFF IN SERVER —>>[%c]\n”,buff[2]);
//printf(“\n count=%d,data1.a=%d,data1.b=%d,data1.opr=%c\n”,count,data1.a,data1.b,data1.opr);

server_addr1.sin_family=AF_INET;
server_addr1.sin_port=htons(6666);
server_addr1.sin_addr.s_addr=inet_addr(“127.0.0.1″);

ret=bind(server_fd1,(const struct sockaddr *)&server_addr1,sizeof(struct sockaddr_in));
if(ret<0)
{
perror(“\n bind is failure”);
exit(-1);
}
ret=listen(server_fd1,5);
if(ret<0)
{
perror(“\n listen is failure”);
exit(-1);
}
int fd1=accept(server_fd1,( struct sockaddr *)&reqclient_addr,&len);
if(fd<0)
{
perror(“\n accept is failure”);
exit(-1);
}
len=sizeof(struct data);
count=write(fd1,buff,3);
printf(“no.of bytes writtern %d\n”,count);
count1=read(fd1,&sum,1);
printf(“count is =%d,sum=%d”,count1,sum);
count=write(fd,&sum,1);
return 0;
}
@

FTP based Client Server project using sockets and threads

Ziaulhaquea356 — Tue, 17 Jun 2014 08:58:07 +0000

Sockets are the fundamental technology for programming software to communicate on TCP/IP networks. A socket provides a bidirectional communication endpoint for sending and receiving data with another socket. Socket connections normally run between two different computers on a LAN or across the Internet, but they can also be used for inter-process communication on a single computer.

It involves the use of Socket Programming. Client creates a local TCP socket specifying the IP and port ?number of server process , the client’s TCP establishes connection to server’s TCP. When contacted by a client, server creates a new socket for server process to communicate with client. Client sends a request to the Server and then Server responds to the client . Data Transmission is over TCP/ IP protocol. Data exchanging protocol is build by creating our own network protocol stack over the socket stack.

program of thread and checking load of processor

Ziaulhaquea356 — Sat, 07 Jun 2014 10:11:08 +0000

head 1.1;
access;
symbols;
locks
root:1.1; strict;
comment @ * @;

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

desc
@simple program of thread.
@

1.1
log
@Initial revision
@

Thread concept

Ziaulhaquea356 — Fri, 06 Jun 2014 07:15:08 +0000

Thread operations include thread creation, termination, synchronization (joins,blocking), scheduling, data management and process interaction.
A thread does not maintain a list of created threads, nor does it know the thread that created it.
All threads within a process share the same address space.
Threads in the same process share:
- Process instructions
- Most data
- open files (descriptors)
- signals and signal handlers
- current working directory
- User and group id
Each thread has a unique:
- Thread ID
- set of registers, stack pointer
- stack for local variables, return addresses
- signal mask
- priority
- Return value: errno
pthread functions return “0? if OK.

Thread

Ziaulhaquea356 — Fri, 06 Jun 2014 07:03:15 +0000

The POSIX thread libraries are a standards based thread API for C/C++. It allows one to spawn a new concurrent process flow. It is most effective on multi-processor or multi-core systems where the process flow can be scheduled to run on another processor thus gaining speed through parallel or distributed processing. Threads require less overhead than “forking” or spawning a new process because the system does not initialize a new system virtual memory space and environment for the process. While most effective on a multiprocessor system, gains are also found on uniprocessor systems which exploit latency in I/O and other system functions which may halt process execution. (One thread may execute while another is waiting for I/O or some other system latency.) Parallel programming technologies such as MPI and PVM are used in a distributed computing environment while threads are limited to a single computer system. All threads within a process share the same address space. A thread is spawned by defining a function and its arguments which will be processed in the thread. The purpose of using the POSIX thread library in your software is to execute software faster

RCS

Ziaulhaquea356 — Tue, 25 Mar 2014 09:44:18 +0000

Name : rcs
Product : Fedora 19
Version : 5.9.0
Release : 1.fc19
URL : http://www.gnu.org/software/rcs/
Summary : Revision Control System (RCS) file version management tools
Description :
The Revision Control System (RCS) is a system for managing multiple
versions of files. RCS automates the storage, retrieval, logging,
identification and merging of file revisions. RCS is useful for text
files that are revised frequently (for example, programs,
documentation, graphics, papers and form letters).

The rcs package should be installed if you need a system for managing
different versions of files.

enter a string and compress with the help of masterarray

Ziaulhaquea356 — Tue, 25 Mar 2014 07:11:20 +0000

head 1.1;
access;
symbols;
locks; strict;
comment @ * @;

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

desc
@master array with compression
@

1.1
log
@Initial revision
@
text
@#include
#include
#include
int main()
{
int i=0,j,len,maslen=1,fd,ret;
char arr[100]={0};
char masterarr[25]={0};
fd=open(“add.c”,O_RDONLY);
if(fd<0)
{
perror(“open”);
goto OUT;
}
printf(“fd=%d\n”,fd);

ret=read(fd,&arr[i],1);
for(i=1;ret>0;i++)
{
ret=read(fd,&arr[i],1);
printf(“\nret=%d,data is %c\n”,ret,arr[i]);
}

len=strlen(arr);
unsigned int ch1,ch2,comp,fd1;
for(i=0;i {
for(j=0;j {
if(j+1==maslen)
{
masterarr[j]=arr[i];
maslen++;
break;
}
else
{
if(masterarr[j]==arr[i])
break;
}
}
}
printf(“masterarr=%s\n”,masterarr);
fd1=open(“compress”,O_CREAT|O_RDWR,777);
if(fd<0)
{
perror(“open”);
goto OUT;
}

for(i=0;i {
for(j=0;j {
if(masterarr[j]==arr[i])
{
ch1=j;
break;
}
}
i++;
for(j=0;j {
if(masterarr[j]==arr[i])
{
ch2=j;
break;
}
}
printf(“value in ch1 %d\n and ch2 %d\n”,ch1,ch2);

ch2=ch2<<4;
comp=ch1|ch2;
printf(“comp=%d”,comp);
write(fd1,&comp,1);
}
return 0;
OUT:
return-1;
}

pointer

Ziaulhaquea356 — Mon, 03 Mar 2014 07:20:24 +0000

pointer-> pointer is a variable that store logical address.it is the only way to express som computation and produces compact and efficient cod.it povides a very powerful tool