fitren http://fitren.blog.sohu.com/ Tue, 1 Jul 2008 09:32:22 +0800 搜狐博客 d753ef3792 http://blog.sohu.com http://js.pp.sohu.com/ppp/blog/images/common/logo_150_60.gif http://blog.sohu.com/ 100 43 搜狐博客 GtkEntry只允许数字输出,及输入变换pixbuf颜色 http://fitren.blog.sohu.com/93178466.html http://fitren.blog.sohu.com/93178466.html#comment fitren Tue, 1 Jul 2008 09:32:22 +0800 gtk http://fitren.blog.sohu.com/93178466.html #include <stdio.h>
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#include <stdlib.h>//malloc
typedef struct {
 GtkWidget *image;
 GdkColor color;
 GdkPixbuf *pixbuf;
 int entry_type;
}tr_data;
gboolean key_filter(GtkWidget *entry,GdkEventKey *event,gpointer data)//number only
{
 switch(event->keyval)
 {
  case GDK_0:
  case GDK_1:
  case GDK_2:
  case GDK_3:
  case GDK_4:
  case GDK_5:
  case GDK_6:
  case GDK_7:
  case GDK_8:
  case GDK_9:
  case GDK_KP_0:
  case GDK_KP_1:
  case GDK_KP_2:
  case GDK_KP_3:
  case GDK_KP_4:
  case GDK_KP_5:
  case GDK_KP_6:
  case GDK_KP_7:
  case GDK_KP_8:
  case GDK_KP_9:
  case GDK_BackSpace:
  case GDK_Return:
  case GDK_KP_Enter:
  case GDK_KP_Space:
  case GDK_Left:
  case GDK_Right:
  case GDK_Up:
  case GDK_Down:
  case GDK_Delete:
  case GDK_Home:
  case GDK_End:
  case GDK_Tab:
   return FALSE;break;
  default:
   return TRUE ;break;
 }
}
void edited(GtkWidget *entry,gpointer data)
{
 tr_data *td = (tr_data *)data;
 int val=0;
 const gchar *entry_name = NULL;
 entry_name = gtk_widget_get_name(entry);
 if(!strcmp(entry_name ,"entry1"))
  td->entry_type = 0;
 else
 {
  if(!strcmp(entry_name,"entry2"))
   td->entry_type = 1;
  else
   td->entry_type = 2;
 }
 val = atoi(gtk_entry_get_text(GTK_ENTRY(entry)));
 switch(td->entry_type)
 {
  case 0:
   if(val<=255 && val >= 0)
    td->color.red = val;
   else
   {
    td->color.red = 255;
    gtk_entry_set_text (GTK_ENTRY(entry),"255");
   }
  break;//r
  case 1:
   if(val<=255 && val >= 0)
    td->color.green = val;
   else
   {
    td->color.green = 255;
    gtk_entry_set_text (GTK_ENTRY(entry),"255");
   }
  break;//g
  case 2:
   if(val<=255 && val >= 0)
    td->color.blue = val;
   else
   {
    td->color.blue = 255;
    gtk_entry_set_text (GTK_ENTRY(entry),"255");
   }
  break;//b
  default:break;
 }
 gint32 pixel = 0;
 pixel = (td->color.red)<<24|
     (td->color.green)<<16|
     (td->color.blue)<<8;
 gdk_pixbuf_fill(td->pixbuf,pixel);
 gtk_image_set_from_pixbuf(GTK_IMAGE(td->image),td->pixbuf); 
}
int main(int argc,char *argv[])
{
  GtkWidget *window1;
  GtkWidget *hbox1;
  GtkWidget *entry1;
  GtkWidget *entry2;
  GtkWidget *entry3;
 GtkWidget *image1;

 tr_data *td = malloc(sizeof(tr_data));
 gtk_init(&argc,&argv);
  window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title (GTK_WINDOW (window1),"window1");
 g_signal_connect(window1,"delete_event",G_CALLBACK(gtk_main_quit),NULL);
 gtk_widget_show(window1);

  hbox1 = gtk_hbox_new (FALSE, 0);
  gtk_widget_show (hbox1);
  gtk_container_add (GTK_CONTAINER (window1), hbox1);

  entry1 = gtk_entry_new ();
 gtk_widget_set_name(entry1,"entry1");
  gtk_widget_show (entry1);
  gtk_box_pack_start (GTK_BOX (hbox1), entry1, TRUE, TRUE, 0);
  gtk_widget_set_size_request (entry1, 20, -1);
  gtk_entry_set_max_length (GTK_ENTRY (entry1), 3);
  gtk_entry_set_text (GTK_ENTRY (entry1), "255");
 g_signal_connect(entry1,"key-press-event",G_CALLBACK(key_filter),td);
 g_signal_connect(entry1,"changed",G_CALLBACK(edited),td);

  entry2 = gtk_entry_new ();
 gtk_widget_set_name(entry2,"entry2");
  gtk_widget_show (entry2);
  gtk_box_pack_start (GTK_BOX (hbox1), entry2, TRUE, TRUE, 0);
  gtk_widget_set_size_request (entry2, 20, -1);
  gtk_entry_set_max_length (GTK_ENTRY (entry2), 3);
  gtk_entry_set_text (GTK_ENTRY (entry2), "0");
 g_signal_connect(entry2,"key-press-event",G_CALLBACK(key_filter),td);
 g_signal_connect(entry2,"changed",G_CALLBACK(edited),td);

  entry3 = gtk_entry_new ();
 gtk_widget_set_name(entry3,"entry3");
  gtk_widget_show (entry3);
  gtk_box_pack_start (GTK_BOX (hbox1), entry3, TRUE, TRUE, 0);
  gtk_widget_set_size_request (entry3, 20, -1);
  gtk_entry_set_max_length (GTK_ENTRY (entry3), 3);
  gtk_entry_set_text (GTK_ENTRY (entry3), "0");
 g_signal_connect(entry3,"key-press-event",G_CALLBACK(key_filter),td);
 g_signal_connect(entry3,"changed",G_CALLBACK(edited),td);

 GdkPixbuf *pixbuf;
 pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,FALSE,8,24,24);
 gint32 pixel = 0;
 GdkColor color;
 color.red = 0xff;
 color.green = 0x00;
 color.blue = 0x00;
 pixel = (color.red)<<24|
     (color.green)<<16|
     (color.blue)<<8;
 gdk_pixbuf_fill(pixbuf,pixel);

 image1 = gtk_image_new_from_pixbuf(pixbuf);
  gtk_widget_show (image1);
  gtk_box_pack_start (GTK_BOX (hbox1), image1, TRUE, TRUE, 0);

 td->image = image1;
 td->color = color;
 td->pixbuf = pixbuf;

 gtk_main();
 return 0;
}

 

]]> libglade用法 http://fitren.blog.sohu.com/91253871.html http://fitren.blog.sohu.com/91253871.html#comment fitren Fri, 27 Jun 2008 13:37:25 +0800 gtk http://fitren.blog.sohu.com/91253871.html 主函数:

#include <stdio.h>
#include <gtk/gtk.h>
#include <glade/glade.h>
#include <glib.h>
#include <libintl.h>//gettext support
#define GLADE_FILE "test.glade"
#define PACKAGE "test.glade"
#define LOCALEDIR "./po"
#define _(string) gettext(string)
#define N_(string) string
void button_clicked(GtkWidget *b)//这个callback函数在.glade声明,此处没有调用处
{
 printf("%s\n",gtk_widget_get_name(b));
 //gtk_widget_set_sensitive(b,FALSE);
}
int main(int argc,char *argv[])
{
 gtk_set_locale();
 bindtextdomain(PACKAGE,LOCALEDIR);
 bind_textdomain_codeset(PACKAGE,"utf-8");

 GtkWidget *window;
 GladeXML *xml;
 gtk_init(&argc,&argv);

 xml = glade_xml_new(GLADE_FILE,NULL,NULL);
 glade_xml_signal_autoconnect(xml);
 
 char *title="test abcedfg";
 GtkWidget *w = glade_xml_get_widget(xml,"window1");
 gtk_window_set_title(GTK_WINDOW(w),title);
 g_signal_connect(w,"delete_event",G_CALLBACK(gtk_main_quit),NULL);
 free(title);
 
 gtk_container_remove(GTK_CONTAINER(w),glade_xml_get_widget(xml,"button1"));
 GtkWidget *box = gtk_vbox_new(FALSE,0);
 gtk_widget_show(box);
 gtk_container_add(GTK_CONTAINER(w),box);


 GtkWidget *button1 = gtk_button_new_from_stock("gtk-quit");
 gtk_widget_show(button1);
 gtk_box_pack_start(GTK_BOX(box),button1,0,FALSE,FALSE);

 button1 = gtk_button_new_from_stock("gtk-ok");
 gtk_widget_show(button1);
 gtk_box_pack_start(GTK_BOX(box),button1,100,FALSE,FALSE);

 xml = glade_xml_new("create_win.glade","vbox_win_create",NULL);//加载另外一个.glade文件，但不被显示出来 ，并取用其中的一个widget-vbox_win_create
 glade_xml_signal_autoconnect(xml);

 GtkWidget *vb = glade_xml_get_widget(xml,"vbox_win_create");
 gtk_box_pack_start(GTK_BOX(box),vb,0,FALSE,FALSE);
 
 xml = glade_xml_new("create_win.glade","frame_type",NULL);
 glade_xml_signal_autoconnect(xml);
 GtkWidget *frame = glade_xml_get_widget(xml,"frame_type");
 gtk_box_pack_start(GTK_BOX(box),frame,0,FALSE,FALSE);

 gtk_main();
 return 0;
}

 

Makefile:

CC=gcc
PRO=load_libglade
SRC=load_libglade.c
LIBS=`pkg-config --libs libglade-2.0`
CFLAGS=`pkg-config --cflags libglade-2.0`
OPTIONS=-rdynamic
all:$(SRC)
 $(CC) -o $(PRO) $(SRC) $(CFLAGS) $(LIBS) $(OPTIONS)
.PHONY:clean
clean:
 @rm -rf *~ $(PRO)

 

]]> gtk 文件复制及progress bar http://fitren.blog.sohu.com/90351889.html http://fitren.blog.sohu.com/90351889.html#comment fitren Tue, 17 Jun 2008 16:36:22 +0800 gtk http://fitren.blog.sohu.com/90351889.html #include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdlib.h>//malloc
#define BUFSIZE 1024
#define SRC "scmj.zip.s"
char DES[16];
#include <gtk/gtk.h>
#include <string.h>//strcat
#define BUFSIZE 1024
int tmp = 0;//copy后新建文件的名字自增参数
void clean(gpointer data)//释放指针,并退出gtk
{
 free(data);
 gtk_main_quit();
}
typedef struct _tr_data //callback函数传递的指针结构,不想用全局变量^_^
{
 GtkWidget *b;
 GtkWidget *pbar;
 GtkWidget *q;
 int ip;
 int op;
 int count;
 int total;
}tran_data;
int die (char *str)//文件读写失败
{
 printf("%s\n",str);
 return 1;
}
int idle_fuc(gpointer data)//循环
{
 tran_data *td = (tran_data *)(data);
 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(td->pbar),(float)td->count/td->total);
 char tmp[16];
 sprintf(tmp,"%.2f",(float)td->count*100/(float)td->total);
 strcat(tmp,"%");
 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(td->pbar),tmp);
 int size;
 char *c = malloc(BUFSIZE);
 size = read(td->ip,c,BUFSIZE);
 if(!size)
 {
  gtk_progress_bar_set_text(GTK_PROGRESS_BAR(td->pbar),"Done!");
  gtk_widget_set_sensitive(td->b,TRUE);
  gtk_widget_set_sensitive(td->q,TRUE);
  free(c); 
  return FALSE;
 }
 write(td->op,c,size);
 td->count+=size;
 return TRUE;
}
void button_clicked(gpointer data)//每次button clicked 的时候进行新的一次copy
{
 tmp++;//change destination file name
 tran_data *td = (tran_data *)data;
 td->count = 0; 
 struct stat *buf;
 buf = malloc(sizeof(struct stat));
 lstat(SRC,buf);
 td->total = buf->st_size;
 free(buf);
 sprintf(DES,"%d",tmp);
 strcat(DES,".zip");
 td->ip = open(SRC,O_RDONLY);
 td->op = open(DES,O_WRONLY|O_CREAT,S_IRUSR|S_IWUSR);
 if(td->ip == -1)
  die("Open input File Faild");
 if(td->op == -1)
  die("Open Output File Faild");
 gtk_widget_set_sensitive(td->b,FALSE);//保证在copy的过程中两个按钮不能作其它事情,直到copy完成
 gtk_widget_set_sensitive(td->q,FALSE);
 td->count = 0;
 g_idle_add(idle_fuc,td);//gtk 循环处理调用
}
int main(int argc,char *argv[])//主程序
{
 gtk_init (&argc,&argv);
 GtkWidget *w = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 gtk_widget_show(w);

 GtkWidget *box = gtk_vbox_new(FALSE,0);
 gtk_container_add(GTK_CONTAINER(w),box);
 gtk_widget_show(box);

 GtkWidget *b = gtk_button_new_from_stock("gtk-execute");
 gtk_box_pack_start(GTK_BOX(box),b,FALSE,FALSE,0);
 gtk_widget_show(b);
 
 GtkWidget *pbar = gtk_progress_bar_new();
 gtk_box_pack_start(GTK_BOX(box),pbar,FALSE,FALSE,0);
 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pbar),"Click button to start copy");

 GtkWidget *q = gtk_button_new_from_stock("gtk-quit");
 gtk_box_pack_start(GTK_BOX(box),q,FALSE,FALSE,0);
 gtk_widget_show(q);
 
 tran_data *td = malloc(sizeof(tran_data));//初始化结构的一些成员,便于在callback函数中传递
 td->b = b;
 td->pbar = pbar;
 td->q = q;
 g_signal_connect_swapped(b,"clicked",G_CALLBACK(button_clicked),td);
 g_signal_connect_swapped(w,"delete_event",G_CALLBACK(clean),td);
 g_signal_connect_swapped(q,"clicked",G_CALLBACK(clean),td);
 gtk_widget_show(pbar);

 gtk_main();
 return 0;
}

]]> gtk sdl 旋转 缩放 图片 http://fitren.blog.sohu.com/89901013.html http://fitren.blog.sohu.com/89901013.html#comment fitren Thu, 12 Jun 2008 12:43:55 +0800 http://fitren.blog.sohu.com/89901013.html //程序source code

#include <stdio.h>
#include <string.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <gtk/gtk.h>
#include <SDL/SDL_rotozoom.h>
#include <gdk/gdkx.h>//GDK_WINDOW_XWINDOW()
#include <unistd.h>   //_exit()
#define WWIDTH 800
#define WHEIGHT 600
#define SDL_WIDTH 600
#define SDL_HEIGHT 480

SDL_Surface *screen = NULL;
int draw_flag = 1;
int flag_zoom = 1;
void draw_render();
void clear_screen(SDL_Surface *screen);

void picture_zoom (SDL_Surface *screen, SDL_Surface *picture,float zoomx,float zoomy,Uint32 interval)
{
 //handle_event();
 clear_screen(screen);
 SDL_Surface *rotozoom_picture = NULL;
 SDL_Rect dest;
    if ((rotozoom_picture=zoomSurface (picture, zoomx,zoomy, 1))!=NULL) {
  dest.x = (screen->w - rotozoom_picture->w)/2;;
  dest.y = (screen->h - rotozoom_picture->h)/2;
  dest.w = rotozoom_picture->w;
  dest.h = rotozoom_picture->h;
  if ( SDL_BlitSurface(rotozoom_picture, NULL, screen, &dest) < 0 ) {
   fprintf(stderr, "Blit failed: %s\n", SDL_GetError());
  }
  SDL_FreeSurface(rotozoom_picture);
 }
 /* Display by flipping screens */
 SDL_Flip(screen);
 SDL_Delay(interval);
}
void picture_rotozoom (SDL_Surface *screen, SDL_Surface *picture,int angle,float zoomx,float zoomy,Uint32 interval)
{
 //handle_event();
 clear_screen(screen);
 SDL_Surface *rotozoom_picture = NULL;
 SDL_Rect dest;
  if ((rotozoom_picture=rotozoomSurfaceXY (picture, angle, zoomx, zoomy, 1))!=NULL) {
  dest.x = (screen->w - rotozoom_picture->w)/2;;
  dest.y = (screen->h - rotozoom_picture->h)/2;
  dest.w = rotozoom_picture->w;
  dest.h = rotozoom_picture->h;
  if ( SDL_BlitSurface(rotozoom_picture, NULL, screen, &dest) < 0 ) {
   fprintf(stderr, "Blit failed: %s\n", SDL_GetError());
  }
  SDL_FreeSurface(rotozoom_picture);
 }

 SDL_Flip(screen);
 SDL_Delay(interval);
}
void clear_screen(SDL_Surface *screen)
{
 int i;
 /* Set the screen to color */
 if ( SDL_LockSurface(screen) == 0 ) {
  Uint8 *pixels;
  pixels = (Uint8 *)screen->pixels;
  for ( i=0; i<screen->h; ++i ) {
   memset(pixels, 0x00,
    screen->w*screen->format->BytesPerPixel);
   pixels += screen->pitch;
  }
  SDL_UnlockSurface(screen);
 }
}
void button_zoom_clicked(GtkWidget *b)
{ 
 if(draw_flag)
  g_idle_add((GSourceFunc)draw_render, b);
 draw_flag = 0;
 flag_zoom = 1;
 gtk_widget_set_sensitive(b,FALSE);
 GList* cl = gtk_container_get_children (GTK_CONTAINER(b->parent));
 int i;
 int len = g_list_length(cl);
// const char *b_label = gtk_button_get_label(GTK_BUTTON(cl->data));
 for(i = 0;i<len;i++)
 {
//  const gchar *label = gtk_button_get_label(GTK_BUTTON(cl->data));
//  if(strcmp(label,b_label))
   gtk_widget_set_sensitive(GTK_WIDGET(cl->data),FALSE);
  cl = cl->next ;
 }
}
void button_rotate_clicked(GtkWidget *b)
{ 
 if(draw_flag)
  g_idle_add((GSourceFunc)draw_render, b);
 draw_flag = 0;
 flag_zoom = 0;
 gtk_widget_set_sensitive(b,FALSE);
 GList* cl = gtk_container_get_children (GTK_CONTAINER(b->parent));
 int i;
 int len = g_list_length(cl);
// const char *b_label = gtk_button_get_label(GTK_BUTTON(cl->data));
 for(i = 0;i<len;i++)
 {
//  const gchar *label = gtk_button_get_label(GTK_BUTTON(cl->data));
 // if(strcmp(label,b_label))
   gtk_widget_set_sensitive(GTK_WIDGET(cl->data),FALSE);
  cl = cl->next ;
 }
}
SDL_Surface *Load_Image(char *filepath)
{
 SDL_Surface *li = IMG_Load(filepath);
 SDL_Surface *op = NULL;
 if(li !=NULL)
 {
  op = SDL_DisplayFormat(li);
  SDL_FreeSurface(li);
  if(op !=NULL)
  {
   Uint32 colorkey = SDL_MapRGB(op->format,0,0x00,0x00);
   SDL_SetColorKey(op,SDL_SRCCOLORKEY,colorkey);
  }
 }
 return op;
}
void draw_render(GtkWidget *b)
{
 SDL_Surface *img1 =NULL;
 img1 = Load_Image("dots.png");
 int i ;
 Uint32 interval = 50;

 if(!draw_flag)
 {
  for(i = 1;i<20;i++)
  {
   if(flag_zoom)
    picture_zoom(screen,img1,(float)i/10,(float)i/10,interval);
   else
    picture_rotozoom(screen,img1,i*36,(float)i/10,(float)i/10,interval);
  }
  
  /*if(SDL_MUSTLOCK(screen))
   if(SDL_LockSurface(screen)<0)
   {
    fprintf(stderr,"Can not LockSurface:%s\n",SDL_GetError);
    SDL_ClearError();
    return ;
   }
   int tick = SDL_GetTicks();
   int i,j,yofs,ofs;

  yofs = 0;
  for(i = 0;i<SDL_HEIGHT;i++)
  {
   for(j = 0,ofs = yofs;j<SDL_WIDTH;j++,ofs++)
   {
    ((unsigned int *)screen->pixels)[ofs] = i * i + j*j + tick;
   }
   yofs += screen->pitch/4;
  }
  if(SDL_MUSTLOCK(screen))
   SDL_UnlockSurface(screen);*/
  
 }
 else
 {
  clear_screen(screen);
  GList* cl = gtk_container_get_children (GTK_CONTAINER(b->parent));
  int i;
  int len = g_list_length(cl);
  for(i = 0;i<len;i++)
  {
   gtk_widget_set_sensitive(GTK_WIDGET(cl->data),TRUE);
   cl = cl->next ;
  }
  i = 10;
  picture_zoom(screen,img1,(float)i/10,(float)i/10,interval);
 }
 draw_flag = 1;
 SDL_UpdateRect(screen,0,0,SDL_WIDTH,SDL_HEIGHT);
}
void delete_event_fun()
{
 gtk_main_quit();
 SDL_Quit();
}

int main(int argc,char *argv[])
{
 gtk_init(&argc,&argv);

 GtkWidget *w = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 gtk_widget_set_size_request(w,WWIDTH,WHEIGHT);
 gtk_widget_realize(w);//important
 g_signal_connect(w,"delete_event",delete_event_fun,NULL);

 gtk_widget_add_events(w, GDK_BUTTON_PRESS_MASK);
 
 GtkWidget *fixed = gtk_fixed_new();
 gtk_container_add(GTK_CONTAINER(w),fixed);
 gtk_widget_show(fixed);

 GtkWidget *b = gtk_button_new_with_label("Rotate");
 gtk_fixed_put(GTK_FIXED(fixed),b,600,0);//position of button,you can costomsize it by your sdl screen position
 gtk_widget_show(b);
 g_signal_connect(b,"clicked",G_CALLBACK(button_rotate_clicked),NULL);

 b = gtk_button_new_with_label("Zoom");
 gtk_fixed_put(GTK_FIXED(fixed),b,600,50);//position of button,you can costomsize it by your sdl screen position
 gtk_widget_show(b);
 g_signal_connect(b,"clicked",G_CALLBACK(button_zoom_clicked),NULL);
 
 char wh [32];
 sprintf(wh,"SDL_WINDOWID=%ld",GDK_WINDOW_XWINDOW(w->window));//important
 putenv(wh);

 if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
  fprintf(stderr,"Couldn't initialize SDL: %s\n",SDL_GetError());
  gtk_main_quit();
 }

 screen = SDL_SetVideoMode(SDL_WIDTH,SDL_HEIGHT,32,SDL_SWSURFACE);
 gtk_widget_show(w);
 gtk_main(); 
 SDL_Quit();
 return 0;
}

Makefile:

CC=gcc
SRC=$(wildcard *.c)
LIBS=`pkg-config --libs gtk+-2.0` `sdl-config --libs`
CFLAGS=`pkg-config --cflags gtk+-2.0` `sdl-config --cflags` -lSDL_image -lSDL_gfx
#PRO=`for file in *.c ;do echo $file | cut -d'.' -f1;done;`
PRO=`echo *.c|cut -d'.' -f1`
all:$(SRC)
 $(CC) $(SRC) $(LIBS) $(CFLAGS)
 @mv a.out $(PRO);
.PHONY:clean
clean:
 @rm  -rf *~  $(PRO)

说明:

  gtk和sdl结合使用,SDL主要用于图片的绘制,等效等,gtk主要用其widgets

  其中SDL要用到sdl_gfx库对图片进行处理

]]> SDL中画线,画圆以及填充的算法(出自计算机图形学,潘云鹤主编) http://fitren.blog.sohu.com/89718885.html http://fitren.blog.sohu.com/89718885.html#comment fitren Tue, 10 Jun 2008 10:06:48 +0800 sdl http://fitren.blog.sohu.com/89718885.html #include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "SDL/SDL.h"
#include "windows.h"
#include "SDL/SDL_image.h"
SDL_Surface *screen = NULL;       //屏幕接口
void put_pixel(SDL_Surface *surface, int x, int y, Uint32 pixel);
Uint32 get_pixel(SDL_Surface *surface, int x, int y);
void draw_point(SDL_Surface *screen,int x,int y,Uint32 color);
void seed_filling(SDL_Surface *screen,int i,int j,Uint32 color_fill,Uint32 boundary_color)
{
 //没有成功
 Uint32 c = get_pixel(screen,i,j);//得到i,j点的颜色
 if((c != boundary_color)&&(c != color_fill))
 {
  //四邻法填充
  put_pixel(screen,i,j,color_fill);
 /* seed_filling(screen,i+1,j,color_fill,boundary_color);
  seed_filling(screen,i-1,j,color_fill,boundary_color);
  seed_filling(screen,i,j+1,color_fill,boundary_color);
  seed_filling(screen,i,j-1,color_fill,boundary_color);*/
 }
}
void plot_circle_points(SDL_Surface *screen,int xc,int yc,int x,int y,Uint32 c)
{
 put_pixel(screen,xc+x,yc+y,c);
 put_pixel(screen,xc-x,yc+y,c);
 put_pixel(screen,xc+x,yc-y,c);
 put_pixel(screen,xc-x,yc-y,c);
 put_pixel(screen,xc+y,yc+x,c);
 put_pixel(screen,xc-y,yc+x,c);
 put_pixel(screen,xc+y,yc-x,c);
 put_pixel(screen,xc-y,yc-x,c);
}
void bresenham_circle(SDL_Surface *screen,int xc,int yc,int radius,Uint32 c)
{
 int x,y,p;
 x = 0;
 y = radius;
 p = 3-2*radius;
 while(x<y)
 {
  plot_circle_points(screen,xc,yc,x,y,c);
  if(p<0)
   p=p+4*x+6;
  else
  {
   p=p+4*(x-y)+10;
   y-=1;
  }
  x+=1;
 }
 if(x == y)
  plot_circle_points(screen,xc,yc,x,y,c);
}
void bresenham_line(SDL_Surface *screen,int x1,int y1,int x2,int y2,Uint32 c)
{
 int dx,dy,x,y,p,const1,const2,inc,tmp;
 dx = x2-x1;
 dy = y2-y1;
 if(dx*dy >= 0)
  inc = 1;
 else
  inc = -1;
 if(abs(dx)>abs(dy))
 {
  if(dx<0)
  {
   tmp = x1;
   x1 = x2;
   x2 = tmp;
   tmp = y1;
   y1 = y2;
   y2 = tmp;
   dx = -dx;
   dy = -dy;
  }
  p = 2*dy-dx;
  const1 = 2*dy;
  const2 = 2*(dy-dx);
  x = x1;
  y = y1;
  put_pixel(screen,x,y,c);
  while(x<x2)
  {
   x++;
   if(p<0)
    p += const1;
   else
   {
    y += inc;
    p += const2;
   }
   put_pixel(screen,x,y,c);
  }
 }
 else
 {
  if(dy<0)
  {
   tmp = x1;
   x1 = x2;
   x2 = tmp;
   tmp = y1;
   y1 = y2;
   y2 = tmp;
   dx = -dx;
   dy = -dy;
  }
  p = 2*dy-dx;
  const1 = 2*dy;
  const2 = 2*(dy-dx);
  x = x1;
  y = y1;
  put_pixel(screen,x,y,c);
  while(y<y2)
  {
   y++;
   if(p<0)
    p += const1;
   else
   {
    x+=inc;
    p+=const2;
   }
   put_pixel(screen,x,y,c);
  }
 }
}
void dda_line(SDL_Surface *screen,int xa,int ya,int xb,int yb,Uint32 c)
{
 float delta_x,delta_y,x,y;
 int dx,dy,steps,k;
 dx = xb-xa;
 dy = yb-ya;
 
 if(abs(dx)>abs(dy))
   steps = abs(dx);
 else
   steps = abs(dy);
 
 delta_x = (float)dx/(float)steps;
 delta_y = (float)dy/(float)steps;
 x = xa;
 y = ya;
 put_pixel(screen,x,y,c);
 for(k = 0;k<steps;k++)
 {
  x+=delta_x;
  y+=delta_y;
  put_pixel(screen,x,y,c);
 }
 return ;
}
/*
 * Return the pixel value at (x, y)
 * NOTE: The surface must be locked before calling this!
 */
Uint32 get_pixel(SDL_Surface *surface, int x, int y)
{
    int bpp = surface->format->BytesPerPixel;
    /* Here p is the address to the pixel we want to retrieve */
    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;

    switch(bpp) {
    case 1:
        return *p;

    case 2:
        return *(Uint16 *)p;

    case 3:
        if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
            return p[0] << 16 | p[1] << 8 | p[2];
        else
            return p[0] | p[1] << 8 | p[2] << 16;

    case 4:
        return *(Uint32 *)p;

    default:
        return 0;       /* shouldn't happen, but avoids warnings */
    }
}

/*
 * Set the pixel at (x, y) to the given value
 * NOTE: The surface must be locked before calling this!
 */
void put_pixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
{
    int bpp = surface->format->BytesPerPixel;
    /* Here p is the address to the pixel we want to set */
    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;

    switch(bpp) {
    case 1:
        *p = pixel;
        break;

    case 2:
        *(Uint16 *)p = pixel;
        break;

    case 3:
        if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
            p[0] = (pixel >> 16) & 0xff;
            p[1] = (pixel >> 8) & 0xff;
            p[2] = pixel & 0xff;
        } else {
            p[0] = pixel & 0xff;
            p[1] = (pixel >> 8) & 0xff;
            p[2] = (pixel >> 16) & 0xff;
        }
        break;

    case 4:
        *(Uint32 *)p = pixel;
        break;
    }
}

void draw_point(SDL_Surface *screen,int x,int y,Uint32 color)
{
    if ( SDL_MUSTLOCK(screen) ) {
        if ( SDL_LockSurface(screen) < 0 ) {
            fprintf(stderr, "Can't lock screen: %s\n", SDL_GetError());
            return;
        }
    }

 put_pixel(screen, x, y, color);

    if ( SDL_MUSTLOCK(screen) ) {
        SDL_UnlockSurface(screen);
    }
    /* Update just the part of the display that we've changed */
    SDL_UpdateRect(screen, x, y, 1, 1);

    return;

}

void apply_surface( int x, int y, SDL_Surface* source, SDL_Surface* destination )
{
 SDL_Rect offset;
 offset.x = x;
 offset.y = y;
 SDL_BlitSurface( source, NULL, destination, &offset );
}
SDL_Surface *load_image( char *filename )
{
    //将图象暂时存储在这里
    SDL_Surface* loadedImage = NULL; 
    //存储最佳的图象
    SDL_Surface* optimizedImage = NULL;
 //导入图象
    loadedImage = IMG_Load( filename );
 //如果导入图象不为空
    if( loadedImage != NULL )
    {
        //建立最佳的图象
        optimizedImage = SDL_DisplayFormat( loadedImage ); 
        //释放老的图象
        SDL_FreeSurface( loadedImage );
  if( optimizedImage != NULL )
  {
   //取得颜色码
   Uint32 colorkey = SDL_MapRGB( optimizedImage->format, 0, 0, 0xFF );
   //设置颜色码
   SDL_SetColorKey( optimizedImage, SDL_RLEACCEL | SDL_SRCCOLORKEY, colorkey );
  }
    }
 //返回最佳的图象
    return optimizedImage;

}

int main( int argc, char* args[] )   //主程序
{
    char msg[500];                       // 得到系统消息
    int done;        
    /* 初始化SDL */

    if (SDL_Init (SDL_INIT_VIDEO) < 0)
    {
        sprintf (msg, "不能初始化 SDL: %s\n", SDL_GetError ());
        MessageBox (0, msg, "Error", MB_ICONHAND);
        exit (1);
    }
    atexit (SDL_Quit); 

    /* 设置 640x480 16-bits 图象模式 */

    screen = SDL_SetVideoMode (800, 600, 32, SDL_SWSURFACE |SDL_DOUBLEBUF);
    if (screen == NULL)
    {
       sprintf (msg, "不能设置成 640x480x16 图象模式: %s\n",
       SDL_GetError ());
       MessageBox (0, msg, "Error", MB_ICONHAND);
       exit (2);
    }

 //SDL_WM_ToggleFullScreen(screen);
/* SDL_VideoInfo *gvi = NULL;
 gvi = SDL_GetVideoInfo();*/
 
   /*设置SDL窗口标题 */
 //SDL_Surface *background=NULL;
 //background=load_image("bg_pic.png");

    SDL_WM_SetCaption ("hello,the world", NULL);

 int i,j;
 Uint32 color = SDL_MapRGB(screen->format,0xff,0xff,0xff);
 //对比以下两种画线算法所花费的时间dda vs bresenham,

//结果bresenham算法在画多条的时候比dda快将近一倍
 Uint32 t1=SDL_GetTicks();
 for(i = 0;i<400;i++)
 {
  for(j = 0;j<300;j++)
   dda_line(screen,0,0,i,j,color);
 }
 Uint32 t2=SDL_GetTicks();

 Uint32 t3=SDL_GetTicks();
 for(i = 0;i<400;i++)
 {
  for(j = 0;j<300;j++)
   bresenham_line(screen,0,0,i,j,color);
 }
 Uint32 t4=SDL_GetTicks();

 char tmp[32];
 sprintf(tmp,"dda:%d\nbresham:%d",t2-t1,t4-t3);
 MessageBox(NULL,tmp,"Message",4);


 bresenham_circle(screen,600,480,100,color);
 Uint32 color_fill = SDL_MapRGB(screen->format,0xff,0x00,0x00);
 //Uint32 gc = get_pixel(screen,501,381);
 Uint32 boundary_color = SDL_MapRGB(screen->format,0xff,0xff,0xff);
 for(i = 500;i<700;i++)
  for(j = 380;j<580;j++)
  {
  // Uint32 gc = get_pixel(screen,i,j);
   seed_filling(screen,i,j,color_fill,boundary_color);
  }

 //seed_filling(screen,500,380,color_fill,boundary_color);
 done = 0;
 int x = 100;
 int y = 100;
 while (!done)
    {
        SDL_Event event;
        /* 检测事件*/
        while (SDL_PollEvent (&event))
        {
            switch (event.type)
            {
            case SDL_KEYDOWN:
                break;
            case SDL_QUIT:
                done = 1;
                break;
   case SDL_KEYUP:
    if(event.key.keysym.sym == SDLK_ESCAPE)
      done = 1;
    break;
            default:
                break;
            }
        }

  //更新屏幕
  if( SDL_Flip( screen ) == -1 )
  {
   return 1;   
  }
 }
    SDL_Quit();
    return 0;   
}

 

]]> Linux设备驱动程序设计入门笔记 2 http://fitren.blog.sohu.com/38626536.html http://fitren.blog.sohu.com/38626536.html#comment fitren Wed, 21 Mar 2007 13:38:10 +0800 技术类 http://fitren.blog.sohu.com/38626536.html http://soft.yesky.com/lesson/1/2648001.shtml
阻塞与非阻塞

　　阻塞操作是指，在执行设备操作时，若不能获得资源，则进程挂起直到满足可操作的条件再进行操作。非阻塞操作的进程在不能进行设备操作时，并不挂起。被挂起的进程进入sleep状态，被从调度器的运行队列移走，直到等待的条件被满足。
    在Linux驱动程序中，我们可以使用等待队列（wait queue）来实现阻塞操作。wait queue很早就作为一个基本的功能单位出现在Linux内核里了，它以队列为基础数据结构，与进程调度机制紧密结合，能够用于实现核心的异步事件通知机 制。等待队列可以用来同步对系统资源的访问，上节中所讲述Linux信号量在内核中也是由等待队列来实现的。　　
示例：
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/wait.h>
#include <asm/semaphore.h>
MODULE_LICENSE("GPL");

#define MAJOR_NUM 254

static ssize_t globalvar_read(struct file *, char *, size_t, loff_t*);
static ssize_t globalvar_write(struct file *, const char *, size_t, loff_t*);

struct file_operations globalvar_fops =
{
    .read=globalvar_read,
    .write=globalvar_write,
};

static int global_var = 0;
static struct semaphore sem;
static wait_queue_head_t outq;
static int flag = 0;

static int __init globalvar_init(void)
{
    int ret;
    ret = register_chrdev(MAJOR_NUM, "globalvar", &globalvar_fops);
    if (ret)
    {
        printk("globalvar_waitqueue register failure");
    }
    else
    {
        printk("globalvar_waitqueue register success");
        init_MUTEX(&sem);
        init_waitqueue_head(&outq);
    }
    return ret;
}

static void __exit globalvar_exit(void)
{
    int ret;
    ret = unregister_chrdev(MAJOR_NUM, "globalvar");
    if (ret)
    {
        printk("globalvar_waitqueue unregister failure");
    }
    else
    {
        printk("globalvar_waitqueue unregister success");
    }
}

static ssize_t globalvar_read(struct file *filp, char *buf, size_t len, loff_t *off)
{
    //等待数据可获得
    if (wait_event_interruptible(outq, flag != 0))
    {
        return - ERESTARTSYS;
    }

    if (down_interruptible(&sem))
    {
        return - ERESTARTSYS;
    }

    flag = 0;
    if (copy_to_user(buf, &global_var, sizeof(int)))
    {
        up(&sem);
        return - EFAULT;
    }
    up(&sem);
    return sizeof(int);
}

static ssize_t globalvar_write(struct file *filp, const char *buf, size_t len,loff_t *off)
{
    if (down_interruptible(&sem))
    {
        return - ERESTARTSYS;
    }
    if (copy_from_user(&global_var, buf, sizeof(int)))
    {
        up(&sem);
        return - EFAULT;
    }
    up(&sem);
    flag = 1;
    //通知数据可获得
    wake_up_interruptible(&outq);
    return sizeof(int);
}

module_init(globalvar_init);
module_exit(globalvar_exit);

写设备/dev/waitqueue
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <fcntl.h>
main()
{
    int fd, num;
    fd = open("/dev/waitqueue", O_RDWR, S_IRUSR | S_IWUSR);
    if (fd != - 1)
    {
        while (1)
        {
            printf("Please input the globalvar:\n");
            scanf("%d", &num);
            write(fd, &num, sizeof(int));        
            //如果输入是0，则退出
            if (num == 0)
            {
                close(fd);
                break;
            }
        }
    }
    else
    {
        printf("device open failure\n");
    }
}

读设备：
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <fcntl.h>
main()
{
    int fd, num;
    fd = open("/dev/waitqueue", O_RDWR, S_IRUSR | S_IWUSR);
    if (fd != - 1)
    {
        while (1)
        {
            read(fd, &num, sizeof(int)); //程序将阻塞在此语句，除非有针对globalvar的输入
            printf("The globalvar is %d\n", num);
            //如果输入是0，则退出
            if (num == 0)
            {
                close(fd);
                break;
            }
        }
    }
    else
    {
        printf("device open failure\n");
    }
}

打开两个终端，分别运行上述两个应用程序，发现当在第二个终端中没有输入数据时，第一个终端没有输出（阻塞），每当我们在第二个终端中给globalvar输入一个值，第一个终端就会输出这个值，
./write
Please input the globalvar:
2
Please input the globalvar:
3
Please input the globalvar:

./read
The globalvar is 2
The globalvar is 3]]> Linux设备驱动程序设计入门 笔记1 http://fitren.blog.sohu.com/38619076.html http://fitren.blog.sohu.com/38619076.html#comment fitren Mon, 26 Mar 2007 10:54:01 +0800 技术类 http://fitren.blog.sohu.com/38619076.html http://soft.yesky.com/lesson/1/2648001.shtml

内核模块
Linux内核的一个模块可以以两种方式被编译和加载：
　　（1）直接编译进Linux内核，随同Linux启动时加载；
　　（2）编译成一个可加载和删除的模块，使用insmod加载（modprobe和insmod命令类似，但依赖于相关的配置文件），rmmod删除。这种方式控制了内核的大小，而模块一旦被插入内核，它就和内核其他部分一样。

示例：
#include <linux/init.h>
#include <linux/module.h>//所有模块都需要的头文件
#include <linux/kernel.h>
#ifndef __KERNEL__
#define __KERNEL__
#endif
#ifndef MODULE
#define MODULE
#endif
static int hello_init(void)
{
    printk(KERN_EMERG"Hello,world!\n");//KERN_EMERG：在插入模块时，在终端打印出信息;KERN_ALERT:在log(/var/log/messages)中显示信息
    char* buf;
    buf=kmalloc(100,GFP_KERNEL);
    char* buf1;
    buf1="This is the hello init!";
    strcpy(buf,buf1);
    printk("%s\n",buf);    
    kfree(buf);
    return 0;
}

static void hello_exit(void)
{
    int i=0;
    for(i=0;i<5;i++)
        printk(KERN_EMERG"%d\n",i);
    printk(KERN_EMERG"Bye!\n");
}

module_init(hello_init);
module_exit(hello_exit);

MODULE_LICENSE("GPL");

Makefile:
OBJ=hello.o
PROG=hello.ko
obj-m := $(OBJ)
KERNELBUILD := /lib/modules/`uname -r`/build
default:
    make -C $(KERNELBUILD) M=$(shell pwd) modules
clean:
    rm -rf *.o .*.cmd *.ko *.mod.c .tmp_versions *~
    
加载hello.ko模块：insmod hello.ko，就会在终端有输出
卸载hello.ko模块：rmmod hello.ko

字符设备驱动程序

Linux主要将设备分为二类：字符设备和块设备。字符设备是指设备发送和接收数据以字符的形式进行；而块设备则以整个数据缓冲区的形式进行。字符设备的驱动相对比较简单。

示例：
//mknod /dev/globalvar c 254 0 建立设备接点，必须与注册的设备号相同
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
MODULE_LICENSE("GPL");

#define MAJOR_NUM 254 //主设备号
static ssize_t globalvar_read(struct file *, char *, size_t, loff_t*);
static ssize_t globalvar_write(struct file *, const char *, size_t, loff_t*);

int globalvar_var=1;

static struct file_operations globalvar_fops={
    .read = globalvar_read,
    .write = globalvar_write,//如果把这里注释，那么设备/dev/globalvar就没有可写的权限
};
/* 
    struct file_operations {
       struct module *owner;
       loff_t (*llseek) (struct file *, loff_t, int);
       ssize_t (*read) (struct file *, char *, size_t, loff_t *);
       ssize_t (*write) (struct file *, const char *, size_t, loff_t *);
       int (*readdir) (struct file *, void *, filldir_t);
       unsigned int (*poll) (struct file *, struct poll_table_struct *);
       int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
       int (*mmap) (struct file *, struct vm_area_struct *);
       int (*open) (struct inode *, struct file *);
       int (*flush) (struct file *);
       int (*release) (struct inode *, struct file *);
       int (*fsync) (struct file *, struct dentry *, int datasync);
       int (*fasync) (int, struct file *, int);
       int (*lock) (struct file *, int, struct file_lock *);
    	 ssize_t (*readv) (struct file *, const struct iovec *, unsigned long,
          loff_t *);
    	 ssize_t (*writev) (struct file *, const struct iovec *, unsigned long,
          loff_t *);
    };


 

struct file {
  mode_t f_mode;
  loff_t f_pos;
  unsigned short f_flags;
  unsigned short f_count;
  unsigned long f_reada, f_ramax, f_raend, f_ralen, f_rawin;
  struct file *f_next, *f_prev;
  int f_owner;         /* pid or -pgrp where SIGIO should be sent */
  struct inode * f_inode;
  struct file_operations * f_op;
  unsigned long f_version;
  void *private_data;  /* needed for tty driver, and maybe others */
};*/

static ssize_t globalvar_read(struct file *filp, char *buf, size_t len, loff_t *off)
{
    //globalvar_var从内核空间复制到用户空间
    if (copy_to_user(buf, &globalvar_var, sizeof(int)))
    {
        return - EFAULT;
    }
    return sizeof(int);
}

static ssize_t globalvar_write(struct file *filp, const char *buf, size_t len, loff_t *off)
{
    //将用户空间的数据复制到内核空间的global_var
    if (copy_from_user(&globalvar_var, buf, sizeof(int)))
    {
        return - EFAULT;
    }
    return sizeof(int);
}
static int globalvar_init(void)
{
    int ret;
    ret=register_chrdev(MAJOR_NUM,"globalvar",&globalvar_fops);//注册字符设备
    if(ret)
    {
        printk("globalvar register failure!\n");
    }
    else
    {
        printk("globalvar register success\n");
    }
    return 0;
}
void globalvar_exit(void)
{
    int ret=unregister_chrdev(MAJOR_NUM,"globalvar");//注消字符设备
    if (ret)
    {    
        printk("globalvar unregister failure\n");
    }
    else
    {
        printk("globalvar unregister success\n");
    }
}
module_init(globalvar_init);
module_exit(globalvar_exit);

写一个应用态的程序来打开字符设备文件:/dev/globalvar
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <fcntl.h>
int main()
{
    int fd, num;
    fd = open("/dev/globalvar", O_RDWR, S_IRUSR | S_IWUSR);
    if (fd != -1 )
    {
        read(fd, &num, sizeof(int));
        printf("The globalvar is %d\n", num);
    
        printf("Please input the num written to globalvar\n");
        scanf("%d", &num);
        int ret=write(fd, &num, sizeof(int));
        
        if(ret==-1)
            printf("Can not write file :/dev/globalvar!\n");
        read(fd, &num, sizeof(int));
        printf("The globalvar is %d\n", num);
        close(fd);
    }
    else
    {
        printf("Device open failure\n");
    }
    return 0;
}

编译后运行结果：The globalvar is 0
Please input the num written to globalvar


并发控制

在驱动程序中，当多个线程同时访问相同的资源时（驱动程序中的全局变量是一种典型的共享资源），可能会引发"竞态"，因此我们必须对共享资源进行并发控制。Linux内核中解决并发控制的最常用方法是自旋锁与信号量（绝大多数时候作为互斥锁使用）。
　　自旋锁与信号量"类似而不类"，类似说的是它们功能上的相似性，"不类"指代它们在本质和实现机理上完全不一样，不属于一类。
　　自旋锁不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环查看是否该自旋锁的保持者已经释放了锁，"自旋"就是"在原地打转"。而信号量则引起调用者睡眠，它把进程从运行队列上拖出去，除非获得锁。这就是它们的"不类"。
　　但是，无论是信号量，还是自旋锁，在任何时刻，最多只能有一个保持者，即在任何时刻最多只能有一个执行单元获得锁。这就是它们的"类似"。
　　鉴于自旋锁与信号量的上述特点，一般而言，自旋锁适合于保持时间非常短的情况，它可以在任何上下文使用；信号量适合于保持时间较长的情况，会只能在进程上下文使用。如果被保护的共享资源只在进程上下文访问，则可以以信号量来保护该共享资源，如果对共享资源的访问时间非常短，自旋锁也是好的选择。但是，如果被保护的共享资源需要在中断上下文访问（包括底半部即中断处理句柄和顶半部即软中断），就必须使用自旋锁。

示例
//mknod /dev/spin c 254 0
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <asm/semaphore.h>
MODULE_LICENSE("GPL");

#define MAJOR_NUM 254

static ssize_t globalvar_read(struct file *, char *, size_t, loff_t*);
static ssize_t globalvar_write(struct file *, const char *, size_t, loff_t*);
static int globalvar_open(struct inode *inode, struct file *filp);
static int globalvar_release(struct inode *inode, struct file *filp);

struct file_operations globalvar_fops =
{
    .read= globalvar_read,
    .write=globalvar_write,
    .open=globalvar_open,
    .release=globalvar_release,    
};

static int global_var = 0;
static int globalvar_count = 0;
static struct semaphore sem;
static spinlock_t spin = SPIN_LOCK_UNLOCKED;

static int __init globalvar_init(void)
{
    int ret;
    ret = register_chrdev(MAJOR_NUM, "globalvar", &globalvar_fops);
    if (ret)
    {
        printk("globalvar register failure");
    }
    else
    {
        printk("globalvar register success");
        init_MUTEX(&sem);
    }
    return ret;
}

static void __exit globalvar_exit(void)
{
    int ret;
    ret = unregister_chrdev(MAJOR_NUM, "globalvar");
    if (ret)
    {
        printk("globalvar unregister failure");
    }
    else
    {
        printk("globalvar unregister success");
    }
}

static ssize_t globalvar_read(struct file *filp, char *buf, size_t len, loff_t *off)
{
    //获得信号量
    if (down_interruptible(&sem))
    {
        return - ERESTARTSYS;
    }    

    //将global_var从内核空间复制到用户空间
    if (copy_to_user(buf, &global_var, sizeof(int)))
    {
        up(&sem);
        return - EFAULT;
    }

    //释放信号量
    up(&sem);

    return sizeof(int);
}

ssize_t globalvar_write(struct file *filp, const char *buf, size_t len, loff_t *off)
{
    //获得信号量
    if (down_interruptible(&sem))
    {
        return - ERESTARTSYS;
    }

    //将用户空间的数据复制到内核空间的global_var
    if (copy_from_user(&global_var, buf, sizeof(int)))
    {
        up(&sem);
        return - EFAULT;
    }

    //释放信号量
    up(&sem);
    return sizeof(int);
}
static int globalvar_open(struct inode *inode, struct file *filp)
{
    //获得自旋锁
    spin_lock(&spin);
    
    //临界资源访问
    if (globalvar_count)
    {
        spin_unlock(&spin);
        return - EBUSY;
    }
    globalvar_count++;

    //释放自旋锁
    spin_unlock(&spin);
    return 0;
}

static int globalvar_release(struct inode *inode, struct file *filp)
{
    globalvar_count--;
    return 0;
}
module_init(globalvar_init);
module_exit(globalvar_exit);

用上面的应用示例来测试，分别两个终端打开相同的字符设备文件：/dev/spin，此时得到的结果不同：
1：./testspin
The globalvar is 0
Please input the num written to globalvar
2：./testspin
Device open failure

表明前面的进程还没有释放，后面的进程就不能打开

]]> 《linux编程宝典》笔记4 http://fitren.blog.sohu.com/37400921.html http://fitren.blog.sohu.com/37400921.html#comment fitren Wed, 21 Mar 2007 10:58:31 +0800 技术类 http://fitren.blog.sohu.com/37400921.html
----------------------------------------------------------------------

SIGHUP 1　　　 　A　　终端挂起或者控制进程终止

 SIGINT 2　　　 　A　　键盘中断（如break键被按下）

 SIGQUIT 3　　 　 C　　键盘的退出键被按下

 SIGILL 4　　 　　C　　非法指令

 SIGABRT 6　　　　 C　　由abort(3)发出的退出指令

 SIGFPE 8　　　　 C　　浮点异常

 SIGKILL 9　　 　 AEF　 Kill信号

 SIGSEGV 11　　 　 C　　无效的内存引用

 SIGPIPE 13　　 　 A　　管道破裂: 写一个没有读端口的管道

 SIGALRM 14　　　 A　　由alarm(2)发出的信号

 SIGTERM 15　　　 A　　终止信号

 SIGUSR1 30,10,16 A　　用户自定义信号1

 SIGUSR2 31,12,17 A　　用户自定义信号2

 SIGCHLD 20,17,18 B　　子进程结束信号

 SIGCONT 19,18,25 　　　进程继续（曾被停止的进程）

 SIGSTOP 17,19,23 DEF　终止进程

 SIGTSTP 18,20,24 D　　控制终端（tty）上按下停止键

 SIGTTIN 21,21,26 D　　后台进程企图从控制终端读

 SIGTTOU 22,22,27 D　　后台进程企图从控制终端写

　　下面的信号没在POSIX.1中列出，而在SUSv2列出

信号　　　 值　 　处理动作　发出信号的原因

 --------------------------------------------------------------------

 SIGBUS 10,7,10 C 总线错误(错误的内存访问)

 SIGPOLL A Sys V定义的Pollable事件，与SIGIO同义

 SIGPROF 27,27,29 A Profiling定时器到

 SIGSYS 12,-,12 C 无效的系统调用 (SVID)

 SIGTRAP 5 C 跟踪/断点捕获

 SIGURG 16,23,21 B Socket出现紧急条件(4.2 BSD)

 SIGVTALRM 26,26,28 A 实际时间报警时钟信号(4.2 BSD)

 SIGXCPU 24,24,30 C 超出设定的CPU时间限制(4.2 BSD)

 SIGXFSZ 25,25,31 C 超出设定的文件大小限制(4.2 BSD)

（对于SIGSYS，SIGXCPU，SIGXFSZ，以及某些机器体系结构下的SIGBUS，Linux缺省的动作是A (terminate)，SUSv2 是C (terminate and dump core)）。

　　下面是其它的一些信号:

信号　　　 值　 　处理动作　发出信号的原因

 ----------------------------------------------------------------------

SIGIOT 6 C IO捕获指令，与SIGABRT同义

 SIGEMT 7,-,7 SIGSTKFLT -,16,- A 协处理器堆栈错误

 SIGIO 23,29,22 A 某I/O操作现在可以进行了(4.2 BSD)

 SIGCLD -,-,18 A 与SIGCHLD同义

 SIGPWR 29,30,19 A 电源故障(System V)

 SIGINFO 29,-,- A 与SIGPWR同义

 SIGLOST -,-,- A 文件锁丢失

 SIGWINCH 28,28,20 B 窗口大小改变(4.3 BSD, Sun)

 SIGUNUSED -,31,- A 未使用的信号(will be SIGSYS)

（在这里，- 表示信号没有实现；有三个值给出的含义为，第一个值通常在Alpha和Sparc上有效，中间的值对应i386和ppc以及sh，最后一个值对应mips。信号29在Alpha上为SIGINFO / SIGPWR ，在Sparc上为SIGLOST。）

　　处理动作一项中的字母含义如下:

    * A 缺省的动作是终止进程
    * B 缺省的动作是忽略此信号
    * C 缺省的动作是终止进程并进行内核映像转储（dump core）
    * D 缺省的动作是停止进程
    * E 信号不能被捕获
    * F 信号不能被忽略

　　上面介绍的信号是常见系统所支持的。以表格的形式介绍了各种信号的名称、作用及其在默认情况下的处理动作。各种默认处理动作的含义是：终止程序是指进 程退出；忽略该信号是将该信号丢弃，不做处理；停止程序是指程序挂起，进入停止状况以后还能重新进行下去，一般是在调试的过程中（例如ptrace系统调 用）；内核映像转储是指将进程数据在内存的映像和进程在内核结构中存储的部分内容以一定格式转储到文件系统，并且进程退出执行，这样做的好处是为程序员提 供了方便，使得他们可以得到进程当时执行时的数据值，允许他们确定转储的原因，并且可以调试他们的程序。

　　注意: 信号SIGKILL和SIGSTOP既不能被捕捉，也不能被忽略。信号SIGIOT与SIGABRT是一个信号。可以看出，同一个信号在不同的系统中值可能不一样，所以建议最好使用为信号定义的名字，而不要直接使用信号的值。

具体实例：
1.alarm唤醒
#include <unistd.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
void handler()
{
    printf("hello\n");
//    _exit(0);
}
int main()
{
    int i;
    signal(SIGALRM,handler);
    alarm(2);
    for(i=1;i<4;i++)
    {
        printf("sleep %d ...\n",i);
        sleep(1);
    }
    return 0;
}
2.pause来暂停执行，直到有信号来唤醒
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
void sigroutine(int signum)
{
    printf("Caught signal SIGINT!\n");
}
int main()
{
//    signal(SIGTERM,&sigroutine);//在终端输入killall pause时，signal捕捉到信号
    signal(SIGINT,&sigroutine);//在终端按下CTL+C时，signal捕捉到信号
    pause();
    printf("Continue!\n");
    return 0;
}

3.多个信号的处理
#include <stdio.h>
#include <signal.h>
#include <time.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>

void sighandler(int signum);
void continuehandler(int signum);
char buffer[200];

int main()
{
    strcpy(buffer,"None\n");
    if(signal(SIGTERM,&sighandler)==SIG_ERR)
    {
        printf("Can not register signal SIGTERM!\n");
    }   
    if(signal(SIGINT,&sighandler)==SIG_ERR)
    {
        printf("Can not register signal SIGINT!\n");
    }       
    if(signal(SIGCONT,&continuehandler)==SIG_ERR)
    {
        printf("Can not register signal SIGCONT!\n");
    }
    while(1)
    {
        fgets(buffer,sizeof(buffer),stdin);
        printf("Input:%s",buffer);
    }
    return 0;
}
void sighandler(int signum)
{
    printf("Caught signal %d.\n",signum);
//    _exit(0);
}
void continuehandler(int signum)
{
    printf("Continuing!\n");
    printf("Your last input was:%s",buffer);
}
/*
[root@fitren signal]# ./signal2
hello world
Input:hello world
Caught signal 2.#ctl+c
Caught signal 15.#这里是另外开一个端，killall signal2

[root@fitren signal]# ./signal2 &
[1] 31993
[root@fitren signal]#

[1]+  Stopped                 ./signal2
[root@fitren signal]# fg
./signal2
Continuing!
Your last input was:None#后台运行之后，再前台运行，这样就触发信号SIGCONT
*/

4.两个程序间的通讯
service.c

#include <stdio.h>
#include <signal.h>
void sigroutine(int signum)
{
    printf("Hello,I received a signal from client!\n");
}
int main()
{
    for(;;)
    {
        signal(SIGTERM,&sigroutine);
        pause();
    }
    return 0;   
}


clients.c

#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
int main()
{
    kill(31485,SIGTERM);
    return 0;   
}
5.阻塞信号示例
#include <stdio.h>
#include <signal.h>
#include <time.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>

void sighandler(int signum);
void continuehandler(int signum);
char buffer[200];

int main()
{
    sigset_t blockset;//声明一个sigset_t类型的变量，这种数据类型是基本的信号集，它包含了一系列的信号
    strcpy(buffer,"None\n");
    if(signal(SIGTERM,&sighandler)==SIG_ERR)
    {
        printf("Can not register signal SIGTERM!\n");
    }   
    if(signal(SIGINT,&sighandler)==SIG_ERR)
    {
        printf("Can not register signal SIGINT!\n");
    }       
    if(signal(SIGCONT,&continuehandler)==SIG_ERR)
    {
        printf("Can not register signal SIGCONT!\n");
    }
    sigemptyset(&blockset);//初始化为空集
    sigaddset(&blockset,SIGTERM);//将信号SIGTERM和SIGINT添加到信号集中
    sigaddset(&blockset,SIGINT);
    while(1)
    {
        sigprocmask(SIG_BLOCK,&blockset,NULL);
        fgets(buffer,sizeof(buffer),stdin);
        printf("Input:%s",buffer);
        /*计算挂起信号的个数
        sigset_t pending;
        int pendingcount=0;
        sigpending(&pending);//填充一个信号集就像前面的手工创建一个信号集一样
        if(sigismember(&pending,SIGINT)) pendingcount++;//计算SIGINT和SIGTERM信号出现的个数
        if(sigismember(&pending,SIGTERM)) pendingcount++;
        printf("There are %d signals pending.\n",pendingcount);
        */
        sigprocmask(SIG_UNBLOCK,&blockset,NULL);//如果在前面有任何信号悬挂而未被处理，它们都将被处理
    }
    return 0;
}
void sighandler(int signum)
{
    printf("Caught signal %d.\n",signum);
//    _exit(0);
}
void continuehandler(int signum)
{
    printf("Continuing!\n");
    printf("Your last input was:%s",buffer);
}
/*[root@fitren signal]# ./signal3
I am sending CTL+C in the middle of the line#在这句话的中间加入CTL+C中断信号，而等待用户输入完毕之后，这个信号才触发，并只显示后面一半的信息
Input:in the middle of the line
Caught signal 2.
I am sending SIGSTOP at the end of the line CTL+Z#在这个地方按下CTL+Z使程序后台挂起
[1]+  Stopped                 ./signal3
[root@fitren signal]# fg
./signal3
Continuing!
Your last input was:in the middle of the line
another line
Input:another line*/
//使用sigation示例
#include <stdio.h>
#include <signal.h>
#include <time.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>

#if defined(__linux__) && ! defined(SL_KERNEL)
#define SL_KERNEL 0x80
#endif


void sighandler(int signum,siginfo_t *info,void *extra);
void continuehandler(int signum,siginfo_t *info,void *extra);
char buffer[200];

int main()
{
    struct sigaction act;
    sigset_t blockset,pending;
    int pendingcount;
    strcpy(buffer,"None\n");
   
    sigemptyset(&blockset);
    act.sa_mask=blockset;
    act.sa_flags=SA_SIGINFO;
   
    act.sa_sigaction=&sighandler;//两个信号共用一个信号处理函数
   
    if(sigaction(SIGTERM,&act,NULL)==-1)
    {
        printf("Can not register signal SIGTERM!\n");
    }   
    if(sigaction(SIGINT,&act,NULL)==-1)
    {
        printf("Can not register signal SIGINT!\n");
    }
   
    act.sa_sigaction=&continuehandler;
    if(sigaction(SIGCONT,&act,NULL)==-1)
    {
        printf("Can not register signal SIGCONT!\n");
    }
   
    sigemptyset(&blockset);//初始化为空集
    sigaddset(&blockset,SIGTERM);//将信号SIGTERM和SIGINT添加到信号集中
    sigaddset(&blockset,SIGINT);
    while(1)
    {
        sigprocmask(SIG_BLOCK,&blockset,NULL);
        fgets(buffer,sizeof(buffer),stdin);
        printf("Input:%s",buffer);
        /*计算挂起信号的个数
        sigset_t pending;
        int pendingcount=0;
        sigpending(&pending);//填充一个信号集就像前面的手工创建一个信号集一样
        if(sigismember(&pending,SIGINT)) pendingcount++;//计算SIGINT和SIGTERM信号出现的个数
        if(sigismember(&pending,SIGTERM)) pendingcount++;
        printf("There are %d signals pending.\n",pendingcount);
        */
        sigprocmask(SIG_UNBLOCK,&blockset,NULL);//如果在前面有任何信号悬挂而未被处理，它们都将被处理
    }
    return 0;   
}
void sighandler(int signum,siginfo_t *info,void *extra)
{
    printf("Caught signal %d.\n",signum);
//    _exit(0);
}
void continuehandler(int signum,siginfo_t *info,void *extra)
{
    printf("Continuing!\n");
    printf("Your last input was:%s",buffer);
}
//执行之后和执行signal3是一样的结果
              struct sigaction {
                  void (*sa_handler)(int);
                  void (*sa_sigaction)(int, siginfo_t *, void *);
                  sigset_t sa_mask;
                  int sa_flags;
                  void (*sa_restorer)(void);
              }

sa_flags:标志及其含义:
        SA_NOCLDSTOP
                     If  signum  is  SIGCHLD, do not receive notification when
                     child processes stop (i.e., when child processes  receive
                     one of SIGSTOP, SIGTSTP, SIGTTIN or SIGTTOU).

              SA_ONESHOT or SA_RESETHAND
                     Restore  the  signal action to the default state once the
                     signal handler has been called.

              SA_ONSTACK
                     Call the signal handler on an alternate signal stack pro-
                     vided  by  sigaltstack(2).   If an alternate stack is not
                     available, the default stack will be used.

              SA_RESTART
                     Provide behaviour compatible with BSD signal semantics by
                     making certain system calls restartable across signals.

              SA_NOMASK or SA_NODEFER
                     Do not prevent the signal from being received from within
                  its own signal handler.

              SA_SIGINFO
                     The signal handler takes 3 arguments, not one.   In  this
                     case,  sa_sigaction  should be set instead of sa_handler.
                     (The sa_sigaction field was added in Linux 2.1.86.)
                    
           siginfo_t {
                  int      si_signo;  /* Signal number */
                  int      si_errno;  /* An errno value */
                  int      si_code;   /* Signal code */
                  pid_t    si_pid;    /* Sending process ID */
                  uid_t    si_uid;    /* Real user ID of sending process */
                  int      si_status; /* Exit value or signal */
                  clock_t  si_utime;  /* User time consumed */
                  clock_t  si_stime;  /* System time consumed */
                  sigval_t si_value;  /* Signal value */
                  int      si_int;    /* POSIX.1b signal */
                  void *   si_ptr;    /* POSIX.1b signal */
                  void *   si_addr;   /* Memory location which caused fault */
                  int      si_band;   /* Band event */
                  int      si_fd;     /* File descriptor */
              }
参考sigaction的man page

申请和释放信号量：
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>

# if defined(__GNU_LIBRARY___)&&! defined(__SEM_SEMUN_UNDEFINED)
#else
    union semun{
        int val;
        struct semid_ds *buf;
        unsigned short int *array;
        struct seminfo *__buf;
    };
#endif

int semheld = 0;
int master = 0;
int id = 0;

void release(int id);
void request(int id);
void delete(void);

int main(int argc,char *argv[])
{
    union semun sunion;
    if(argc<2)//如果不带参数，就创建一个新的信号量
    {
        id=semget(IPC_PRIVATE,1,SHM_R|SHM_W);
        if(id!=-1)
        {
            atexit(&delete);
            sunion.val=1;
            if(semctl(id,0,SETVAL,sunion)==-1)
            {   
                printf("Semctl failed:%s\n",strerror(errno));
                exit(255);
            }
        }
        master=1;
    }
    else
    {
        id=atoi(argv[1]);
        printf("Using exiting semaphore %d.\n",id);
    }
    if(id==-1)
    {
        printf("Semaphore request failed:%s.\n",strerror(errno));
        return 0;
    }
    printf("Successfully allocated semaphore id\033[32m %d\n\033[m",id);
    while(1)
    {
        int selection;
        printf("\nStatus:%d resources held by this process.\n",semheld);
        printf("Menu:\n");
        printf("1.release a resource\n");
        printf("2.Request a resource\n");
        printf("3.Exit this process\n");
        scanf("%d",&selection);
       
        switch(selection)
        {
            case 1: release(id);break;
            case 2: request(id);break;
            case 3:exit(0);break;
        }
    }
    return 0;
}
void release(int id)
{
    struct sembuf sb;
    if(semheld < 1)
    {
        printf("\033[31mI don't have any resources:nothing to release.\n\033[m");
        return;
    }
    //信号量的最大值为1,并且对进程来说，这表明资源正在使用中，要使用必须等待
    sb.sem_num=0;//指定信号量中要操作的信号量：0表示第一个
    sb.sem_op =1;//操作指定要完成的操作，正数表示信号量值应该增加，负数从信号量值中减去相应的值，表示资源的消耗
    sb.sem_flg=0;//操作标志:SEM_UNDO进程在没有释放消耗的资源退出，则这些资源将被操作系统释放。IPC_NOWAIT：函数调用将是非阻塞的
    semop(id,&sb,1);
    semheld--;
    printf("\033[32mResource released.\n\033[m");
}
void request(int id)
{
    struct sembuf sb;
    if(semheld>0)
    {
        printf("\033[31mI already hold the resource;not requesting another one.\n\033[m");
        return ;
    }
    sb.sem_num=0;
    sb.sem_op=-1;
    sb.sem_flg=0;
    printf("\033[32mRequeseing resource ...\033[m");
    fflush(stdout);
    semop(id,&sb,1);
    semheld++;
    printf("\033[32mdone.\n\033[m");
}
void delete(void)
{
    printf("Master exiting:deleting semaphore.\n");
    if(semctl(id,0,IPC_RMID,0)==-1)
        printf("Error releasing semaphore.\n");
}

内存共享：
申请一段内存，并向里面写数据：
#include <sys/shm.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
typedef struct{
        char name[20];
        int age;
} info;
int main()
{
        int id,i;
        key_t key;
    char *str="Hello world!";
    int len=strlen(str);
    info *info_p;
    char* name = "/dev/null";
    key = ftok(name,0);/*先用ftok创建一个key,再调用shmget，创建一块共享内存区域*/
    if(key==-1)
    {   
        perror("ftok");
        return 1;
    }
    id=shmget(key,4096,IPC_CREAT);      
    if(id==-1)
    {
        perror("shmget");
        return 1;
    }

    info_p=(info*)shmat(id,NULL,0);/*将这块共享内存区附加到自己的内存段*/
    for(i = 0;i<len;i++)
    {
        memcpy((*(info_p+i)).name,&str[i],1);
        (*(info_p)).age=20;
    }
    info_p->age=20;
    if(shmdt(info_p)==-1)/*写数据完毕，将其从自己的内存段中“删除”出去*/
    {
        perror("shmdt");
        return 1;
    }
    return 0;
}

读共享部分数据：
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
typedef struct{
        char name[100];
        int age;
} people;
main(int argc, char** argv)
{
        int shm_id;
        key_t key;
    char *str="Hello world!";
    int len=strlen(str);
    char buf[len];
    strcpy(buf,str);
        people *p_map;
        char* name = "/dev/null";
        key = ftok(name,0);
        if(key==-1)
                perror("ftok error");
/*先用ftok创建一个key,再调用shmget，创建一块共享内存区域*/
        shm_id=shmget(key,4096,IPC_CREAT);      
        if(shm_id==-1)
        {
                perror("shmget error");
                return;
        }
/*将这块共享内存区附加到自己的内存段*/
        p_map=(people*)shmat(shm_id,NULL,0);
    memset(buf,0,len);
    int i;
    for(i=0;i<len;i++)
        strcat(buf,(*(p_map+i)).name);
    printf("%s\n",buf);
    printf("%d\n",p_map->age);
/*写数据完毕，将其从自己的内存段中“删除”出去*/
        if(shmdt(p_map)==-1)
                perror(" detach error ");
}


]]> 《linux编程宝典》笔记3 http://fitren.blog.sohu.com/36650441.html http://fitren.blog.sohu.com/36650441.html#comment fitren Fri, 9 Mar 2007 10:34:21 +0800 技术类 http://fitren.blog.sohu.com/36650441.html #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
    FILE *fp_r,*fp_w;
    fp_r=popen("ls|grep fork","r");
    fp_w=popen("sed 's/fork/FORK/g'","w");
    char buf_r[128];
    while(fgets(buf_r,sizeof(buf_r),fp_r))
    {
        fputs(buf_r,fp_w);
    }
    pclose(fp_r);
    pclose(fp_w);    
    return 0;
}

用pipe实现父子进程之间通信，主要是父子进程为pipe的两端，一端写，一端读
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/wait.h>

int main()
{
    int dp;
    int fd[2];   
    char *buf;
   
    buf=malloc(100);
    int pid;
   
    memset(buf,0,sizeof(buf));
   
    int flag=1;
    if(pipe(fd)==0)
    {
        pid=fork();
        if(pid==0)
        {
            flag++;
            char *buf_w=malloc(100);
            sprintf(buf_w,"%d",flag);
            write(fd[1],buf_w,strlen(buf_w));           
            printf("Write \"%s\" to the parent!\n",buf_w);
//            _exit(0);       
        }
        else
        {
            read(fd[0],buf,10);
            printf("Read \"%s\" from the child!\n",buf);
            printf("flag=%d\n",flag=atoi(buf));
//            _exit(0);
        }
    }   
    return 0;
}

用wait让父进程等待子进程完成之后再执行
#include <stdio.h>
#include <signal.h>
#include <sys/wait.h>
int main()
{
    int pid;
    pid=fork();
    if(pid==0)
    {   
        printf("The child will sleep 5 seconds!\n");
        sleep(5);
    }
    else
    {
        waitpid(-1,NULL,0);
        printf("The parent will sleep 5 seconds!\n");
        sleep(5);
        printf("The parent is exiting now!\n");
    }
    return 0;
}

va_list ，可变参数函数用法
#include <stdio.h>
#include <unistd.h>
#include <stdarg.h>
#include <time.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>

int tprintf(const char *fmt, ...);
void realsleep(int seconds);
void waitchildren(int signum);
int main(void)
{
    pid_t pid;
    pid=fork();
   
    if(pid==0)
    {
        tprintf("Hello from child process!\n");
        tprintf("The child is sleep for 5 seconds.\n");
        realsleep(5);
        tprintf("The child is exiting now!\n");
    }
    else
        if(pid!=-1)
        {
            signal(SIGCHLD,(void *)waitchildren);
            tprintf("Hello from the parent,pid:%d.\n",getpid());
            tprintf("The parent has forked process %d.\n",pid);
            waitpid(pid,NULL,0);
            tprintf("The child has stopped,Sleeping for 5 seconds.\n");
            realsleep(5);
            tprintf("The parent is exiting now.\n");
        }
        else
        {
            tprintf("There is an error with fork!\n");
        }
    return 0;
}
int tprintf(const char *fmt, ...)
{
    va_list args;
    struct tm *tstruct;
   
    time_t tsec;
   
    tsec=time(NULL);
    tstruct=localtime(&tsec);
    printf("%02d:%02d:%02d %05d|",
        tstruct->tm_hour,
        tstruct->tm_min,
        tstruct->tm_sec,
        getpid());
    va_start(args,fmt);//读取不定参数的固定参数后的第一个参数
    vprintf(fmt,args);//把参数中变量的值打印出来，eg.”Hello from the parent,pid:%d.\n“中把%d替换成实际值，如果用printf,则打印出来的是”Hello from the parent,pid:%d.\n“没有替换成具体的值
    va_end(args);
    return 0;
}
void waitchildren(int signum)
{
    pid_t pid;

    while ((pid=waitpid(-1,NULL,WNOHANG))>0)
    {
        tprintf("Caught the exit of child process %d.\n",pid);
    }
}
void realsleep(int seconds)
{
    while(seconds)
    {
        seconds=sleep(seconds);
        if(seconds)
        {
            tprintf("Restarting interrupted sleep for %d more seconds,\n",seconds);
        }
    }
}
获取文件信息：

#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/types.h>
int main(int argc,char *argv[])
{
    if(argc!=2)
    {
        printf("Usage:%s filename\n",argv[0]);
        _exit(0);
    }
    printf("The information for file %s:\n",argv[1]);

    struct stat sbuf;
    if(lstat(argv[1],&sbuf)== -1)
    {
        printf("lstat error!\n");
        _exit(0);
    }
    printf("Device:%d\n",sbuf.st_dev);
    if(S_ISREG(sbuf.st_mode))
        printf("Reagular file:Yes\n");
    else printf("Reagular file:No\n");
    printf("Owner uid:%d\n",sbuf.st_uid);
    printf("Permisson:%o\n",sbuf.st_mode&(S_IRWXU|S_IRWXG|S_IRWXO));
    printf("Other execute permision:%o\n",sbuf.st_mode&S_IXOTH);   
    return 0;
}

setuid:

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

int try_open()
{
    char *filename="/root/xorg.conf.bak";
    int fd=open(filenam