How to Use _damonize system call in Linux

yes but not in while(1) loop

So where exactly is your problem with this?

i need to write a program to call a function for every 5 seconds and should not wait in while(1)
loop

Use sleep()

The Question is very simple how to avoid while(1) in code which is using SIGALRM
like this

#include <stdio.h>
#include <signal.h>

int wakeUp() {

        printf("Wake up \n");
        signal(SIGALRM,wakeUp);
        alarm(1);

}

int main() {
        signal(SIGALRM,wakeUp);
        alarm(1);
        while(1);
        return(0);

}

How to avoid while(1) in the above

I attached a code snippet for implementation kernel threads functions (you'll see that daemonize is used inside).

This an example of independent thread that will print something every 5 seconds and exit after repeating it 100 times:

static void my_thread(kthread_t *kthread)
{
  int f;
  init_kthread(kthread, "my_thread");

  for (f=0; f<10; f++)
  {
    printk(KERN_INFO "Hello world");
    sleep(5);
  }

  exit_kthread(kthread);
}


kthread_t my_thread_handle;
start_kthread(my_thread, &my_thread_handle);

/* kthread.h */
#ifndef _KTHREAD_H
#define _KTHREAD_H
#include <linux/config.h>
#include <linux/version.h> 
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/wait.h> 
#include <asm/unistd.h>
#include <asm/semaphore.h> 
/* a structure to store all information we need for our thread */
typedef struct kthread_struct
{
  /* private data */ 
  /* Linux task structure of thread */
  struct task_struct *thread;
  /* function to be started as thread */
  void (*function) (struct kthread_struct *kthread);
  /* semaphore needed on start and creation of thread. */
  struct semaphore startstop_sem; 
  /* public data */ 
  /* queue thread is waiting on. Gets initialized by
     init_kthread, can be used by thread itself.
  */
  wait_queue_head_t queue;
  /* flag to tell thread whether to die or not.
     When the thread receives a signal, it must check
     the value of terminate and call exit_kthread and terminate
     if set.
  */
  int terminate;
  /* additional data to pass to kernel thread */
  void *arg;
} kthread_t; 
/* prototypes */ 
/* start new kthread (called by creator) */
void start_kthread(void (*func)(kthread_t *), kthread_t *kthread); 
/* stop a running thread (called by "killer") */
void stop_kthread(kthread_t *kthread); 
/* setup thread environment (called by new thread) */
void init_kthread(kthread_t *kthread, char *name); 
/* cleanup thread environment (called by thread upon receiving termination signal) */
void exit_kthread(kthread_t *kthread); 
#endif 
/*==========================================================================*/
/* kthread.c */
#include <linux/config.h>
#include <linux/version.h> 
#if defined(MODVERSIONS)
#include <linux/modversions.h>
#endif
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/wait.h>
#include <linux/signal.h>
#include <linux/smp_lock.h> 
#include <asm/semaphore.h> 
#include "kthread.h" 
/* create a new kernel thread. Called by the creator. */
void start_kthread(void (*func)(kthread_t *), kthread_t *kthread)
{
  /* initialize the semaphore:
     we start with the semaphore locked. The new kernel
     thread will setup its stuff and unlock it. This
     control flow (the one that creates the thread) blocks
     in the down operation below until the thread has reached
     the up() operation.
  */
  init_MUTEX_LOCKED(&kthread->startstop_sem); 
  /* store the function to be executed in the data passed to the launcher */
  kthread->function = func;
        
  kernel_thread((int (*)(void *))kthread->function, (void *) kthread, 0); 
  /* wait till it has reached the setup_thread routine */
  down(&kthread->startstop_sem);
} 
/* stop a kernel thread. Called by the removing instance */
void stop_kthread(kthread_t *kthread)
{
  if (kthread->thread == NULL)
  {
/*    printk(KERN_DEBUG "KTHREAD: stop_kthread: killing non existing thread!\n");*/
    return;
  } 
  /* this function needs to be protected with the big
	   kernel lock (lock_kernel()). The lock must be
     grabbed before changing the terminate
	   flag and released after the down() call. */
  lock_kernel();
        
  /* initialize the semaphore. We lock it here, the
     leave_thread call of the thread to be terminated
     will unlock it. As soon as we see the semaphore
     unlocked, we know that the thread has exited.
	*/
  init_MUTEX_LOCKED(&kthread->startstop_sem); 
  /* We need to do a memory barrier here to be sure that
     the flags are visible on all CPUs. 
  */
  mb(); 
  /* set flag to request thread termination */
  kthread->terminate = 1; 
  /* We need to do a memory barrier here to be sure that
     the flags are visible on all CPUs. 
  */
  mb();
  kill_proc(kthread->thread->pid, SIGKILL, 1);
       
  /* block till thread terminated */
  down(&kthread->startstop_sem); 
  /* release the big kernel lock */
  unlock_kernel();
} 
/* initialize new created thread. Called by the new thread. */
void init_kthread(kthread_t *kthread, char *name)
{
  daemonize(name, 0);
  /* lock the kernel. A new kernel thread starts without
     the big kernel lock, regardless of the lock state
     of the creator (the lock level is *not* inheritated) */
  lock_kernel(); 
  /* fill in thread structure */
  kthread->thread = current; 
  /* set signal mask to what we want to respond */
  siginitsetinv(&current->blocked, sigmask(SIGKILL)|sigmask(SIGINT)|sigmask(SIGTERM)); 
  /* initialise wait queue */
  init_waitqueue_head(&kthread->queue); 
  /* initialise termination flag */
  kthread->terminate = 0; 
  /* set name of this process (max 15 chars + 0 !) */
  sprintf(current->comm, name);
        
  /* let others run */
  unlock_kernel(); 
  /* tell the creator that we are ready and let him continue */
  up(&kthread->startstop_sem); 
/*  printk(KERN_DEBUG "KTHREAD started thread: %s\n", name);*/
} 
/* cleanup of thread. Called by the exiting thread. */
void exit_kthread(kthread_t *kthread)
{
  /* we are terminating */ 
	/* lock the kernel, the exit will unlock it */
  lock_kernel();
  kthread->thread = NULL;
  mb(); 
  /* notify the stop_kthread() routine that we are terminating. */
	up(&kthread->startstop_sem);
	/* the kernel_thread that called clone() does a do_exit here. */ 
	/* there is no race here between execution of the "killer" and real termination
	   of the thread (race window between up and do_exit), since both the
	   thread and the "killer" function are running with the kernel lock held.
	   The kernel lock will be freed after the thread exited, so the code
	   is really not executed anymore as soon as the unload functions gets
	   the kernel lock back.
	   The init process may not have made the cleanup of the process here,
	   but the cleanup can be done safely with the module unloaded.
	*/
/*  printk(KERN_DEBUG "KTHREAD: ended thread %s\n", current->comm);*/
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:

you can replace the while(1) with for example reading some input like:

int help;
help = fgetc(stdin);

That would make the program wait until you press either enter or CTRL+D.

while(1); is a no-no. It will soak up all available CPU.
Since you are already using SIGALRM, you cannot do while(1) sleep(1); because sleep() also uses SIGALRM.
But you *can* use nanosleep(), because it doesn't use any signals. The SIGALRM will interrupt it, so you can nanosleep as long as you like. You still need the while(1), but only to restart nanosleep once per SIGALRM received.
It is good practice to do as little as possible in a signal handler. Reinstating the signal handler is fine: to avoid that necessity, you can use the more modern sigaction call. Otherwise, best practice is to set a flag for the main program to action, and return. Calling printf() in particular is not a good idea, since the signal you are handling might have interrupted another printf() if you see what I mean.

See next post for some ideas

"Otherwise, best practice is ..." should be "Either way, best practice is ..."

This is not the "next post" mentioned in the previous post, that post is still to come :)

It's always a good idea to compile with option "-Wall". Also I always use "-Wstrict-prototypes -Wmissing-prototypes", which has found a few problems for me in the past.

12:31:05$ gcc -Wall -g3 -ggdb ee52.c -o ee52
ee52.c: In function 'wakeUp':
ee52.c:10: warning: passing argument 2 of 'signal' from incompatible pointer type
ee52.c:11: warning: implicit declaration of function 'alarm'
ee52.c:13: warning: control reaches end of non-void function
ee52.c: In function 'main':
ee52.c:16: warning: passing argument 2 of 'signal' from incompatible pointer type

Ok they're just warnings, but a warning can indicate a program which will nor tun correctly. So let's fix them:-

ee52.c:10: warning: passing argument 2 of 'signal' from incompatible pointer type: from the man page, we see that the signal handler given to signal() should be a function returning void (i.e. not returning anything) and taking an integer argument. Make that change and try again:

4c4
< int wakeUp() {
---
> void wakeUp(int signum) {

12:43:12$ gcc -Wall -g3 -ggdb ee52.c -o ee52
ee52.c: In function 'wakeUp':
ee52.c:11: warning: implicit declaration of function 'alarm'

We are missing the header that describes the alarm() system call. From "man -s 2 alarm" we see that it is unistd.h, so insert it:

2a3
> #include <unistd.h>

12:50:39$ gcc -Wall -g3 -ggdb ee52.c -o ee52
12:50:44$

The warning-free program is the 1st listing below.

Humor an old man and let's fix -Wstrict-prototypes -Wmissing-prototypes:-

12:56:14$ gcc -Wall -g3 -ggdb ee52.c -o ee52 -Wstrict-prototypes -Wmissing-prototypes
ee52.c:9: warning: no previous prototype for 'wakeUp'
ee52.c:17: warning: function declaration isn't a prototype

One could fix "no previous prototype" by inserting the line:

void wakeUp(int signum);

as a prototype before the function declaration. But there's a quicker way (in terms of programmer's time) - just make it static. It is a style of programming that not everyone agrees with (to put all static declarations before the mainline thus avoiding the need for prototypes) but a common style nevertheless.:

< void wakeUp(int signum) {
---
> static void wakeUp(int signum) {

13:08:05$ gcc -Wall -g3 -ggdb ee52.c -o ee52 -Wstrict-prototypes -Wmissing-prototypes
ee52.c:17: warning: function declaration isn't a prototype

The "function declaration isn't a prototype" message appears because you declared main() with empty parentheses. Gcc can't be sure if that isn't an old-style function declaration (you don't want to know about those:) so raises a warning. You explicitly have to tell gcc that main() takes no arguments

17c17
< int main() {
---
> int main(void) {

13:14:54$ gcc -Wall -g3 -ggdb ee52.c -o ee52 -Wstrict-prototypes -Wmissing-prototypes
13:15:02$

Hope you're still reading - now to fix the program:

7a8,12
> #include <time.h>                  /* For nanosleep */
> 
> #define WAIT_TIME 5
> 
> static int flag = 0;               /* For the handler to set */
11d15
<     printf("Wake up \n");
13c17,18
<     alarm(1);
---
>     alarm(WAIT_TIME);
>     flag = 1;
17a23,27
>     
>     struct timespec req;           /* Requested wait time */
>     
>     req.tv_sec = 1;
>     req.tv_nsec = 500000000;
19,20c29,38
<     alarm(1);
<     while(1);
---
>     alarm(WAIT_TIME);
>     while(1)
>     {
>         nanosleep(&req, NULL);
>         if (flag)
>         {
>             flag = 0;
>             printf("Woken by alarm - do your processing here\n");
>         }
>     }

I changed back to 5 second alarm as you originally mentioned.
The nanosleep time is less than the alarm time just in case the alarm gets missed (most unlikely). You could have a nanosleep time of 100 seconds. Best not to make it an exact fraction of the alarm time - you could just possibly miss an alarm if it went off outside of nanosleep. Hence I set it at 1.5 secs.

If you can find the running program in "top", it certainly stays in the S state.

I really would caution against doing your processing in the signal handler even though in this simple example you might get away with it.

12:52:41$ cat ee52.c
/*
Warning-free with:
gcc -Wall -g3 -ggdb ee52.c -o ee52
*/
#include <stdio.h>
#include <signal.h>
#include <unistd.h> 
void wakeUp(int signum) { 
    printf("Wake up \n");
    signal(SIGALRM,wakeUp);
    alarm(1); 
} 
int main() {
    signal(SIGALRM,wakeUp);
    alarm(1);
    while(1);
    return(0); 
} 
================================================ 
13:15:02$ cat ee52.c
/*
Warning-free with:
gcc -Wall -g3 -ggdb ee52.c -o ee52 -Wstrict-prototypes -Wmissing-prototypes
*/
#include <stdio.h>
#include <signal.h>
#include <unistd.h> 
static void wakeUp(int signum) { 
    printf("Wake up \n");
    signal(SIGALRM,wakeUp);
    alarm(1); 
} 
int main(void) {
    signal(SIGALRM,wakeUp);
    alarm(1);
    while(1);
    return(0); 
} 
================================================ 
14:15:15$ cat ee52.c
/*
Warning-free with:
gcc -Wall -g3 -ggdb ee52.c -o ee52 -Wstrict-prototypes -Wmissing-prototypes
*/
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <time.h>                  /* For nanosleep */ 
#define WAIT_TIME 5 
static int flag = 0;               /* For the handler to set */ 
static void wakeUp(int signum) { 
    signal(SIGALRM,wakeUp);
    alarm(WAIT_TIME);
    flag = 1; 
} 
int main(void) {
    
    struct timespec req;           /* Requested wait time */
    
    req.tv_sec = 1;
    req.tv_nsec = 500000000;
    signal(SIGALRM,wakeUp);
    alarm(WAIT_TIME);
    while(1)
    {
        nanosleep(&req, NULL);
        if (flag)
        {
            flag = 0;
            printf("Woken by alarm - do your processing here\n");
        }
    }
    return(0); 
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:

thank you guys for the suggestions and when i tried with GMainloop using the glib library and avoided while(1); loop and now the Process status is always show as S sleep state.

but what is the trick of gmainloop

I think GMainloop  waits for X events. As such, it is likely doing (select or poll) or a blocking i/o. You could find out what exactly it is doing by using the strace command e.g.

strace -p $(pgrep YourApp)

where "YourApp" is the name of your program. strace won't tell you this, but GMainloop is probably in a while(1) loop or the equivalent. So you are simply (and unnecessarily) getting another package to do your dirty work for you.
In my last post, I think I forgot to mention that nanosleep() will get interrupted when the alarm goes off, so timing will be as accurate as alarm() is.

Thanks for the suggestions guys but how the
gmainloop in glib is able to do the trick without using while(1);

It probably does use while(1), it's just that it does something in the middle (such as a blocking i/o) so that very little CPU is used. A blocking i/o will be interrupted by receipt of a caught signal, just as nanosleep would be. You are wasting your time calling GMainloop.

you mean using  nanosleep(&req, NULL); is more efficient way than GMainLoop ?

Yes absolutely. Dragging in all the GMainLoop code just makes your program bigger for no good reason. Rather than sitting on a blocking i/o, it may be in poll() or select() but whatever it's doing it's doing you no good.

Last question how nanosleep() function in while(1) loop is managing  CPU state with
Suspend/Sleep Mode.

While in nanosleep(), the process is shown by top as sleeping. No CPU is being used. Is that what you were asking?

exactly how is this process shown in Sleep State ?

There's an S against it in top. (You can only see it in top by using -p {pid of program} unless you have so few processes that they all fit on your screen).
From man top:

       w: S  --  Process Status
          The status of the task which can be one of:
             'D' = uninterruptible sleep
             'R' = running
             'S' = sleeping
             'T' = traced or stopped
             'Z' = zombie

          Tasks shown as running should be more properly thought of as 'ready to run'  --  their task_struct is simply represented on the Linux run-queue.  Even without a true SMP machine, you may see numerous
          tasks in this state depending on top's delay interval and nice value.

I verified with ps -elf command the Process Status is always 'S' Sleeping State with while(1) nanosleep.  
My question is how is this process in sleep state and able to schedule timer function at intervals
when sigalrm is expired and the process never shown as R running state even though in while(1);

The process is in R state for such a short time that top never gets to display it. If you did something that took a few seconds of CPU to complete, then top would show it. See a little experiment of mine below

20:50:24$ cat ee53.c
/*
gcc -Wall -Wmissing-prototypes -Wstrict-prototypes -g3 -ggdb ee53.c -o ee53
*/
int main(void)
{
  int i;
  for (i=1; i;)
    i++;
  return 0;
}
20:50:42$ time ./ee53 
real    0m10.701s
user    0m10.701s
sys     0m0.000s
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16: