BlogJava-离弦之ray的技术天空-随笔分类-Linux&C

linux 更新

离弦之ray的技术天空 — Wed, 14 Feb 2007 17:43:00 GMT

    好久没进入linux系统了，今天心血来潮，一进去，想玩一下更新系统。然后就从想用那个图形界面的更新程序。可惜阿，点上去都说有一个程序正在读取软件信息。于是重启，但还是如此。
    突然报出有240个软件包可以更新，原来是自动更新在作怪。

    然后就顺理成章地点吧，还挺顺利，它就开始更新了。但更新着就在那不动了，奇慢无比。

    在老婆的指导下，我上网查了一下yum的用法。

    打开终端。
    首先使用yum list来查看更新列表，刷的一下出来好多。
    然后使用yum update，它会检查每个要更新的软件包的头，得到一些信息，包括软件包的大小等等。

    会计算出总的要下载的大小，问你是否要下载。
    乖乖，一共590m，我选择了y，开始下载……

    漫长的等待。
    然后会提示你，你再选择y确定一下就好。
    弄完后半死，重启一下后一切正常。

    但重启时发现，启动时选择系统的时候linux有了两个选项，只有版本信息的微小差异。倒是不影响你选择进入linux
    就是看得不是很爽。于是上网搜索了一下，知道这个信息由文件系统/boot/grub/grub.conf来决定。
    于是研究了一下它，删掉了那个版本比较旧的选项，再把默认启动系统改为default = 1 （因为现在是两个从0开始编号，windows是1，一开始三个的时候，windows是2）

     至此，更新彻底完成！

离弦之ray的技术天空 2007-02-15 01:43 发表评论

FIFO

离弦之ray的技术天空 — Tue, 20 Jun 2006 15:42:00 GMT

A FIFO is similar to a pipe. A FIFO is a one-way flow of data (First In First Out). FIFOs have a name, so unrelated processes can share the FIFO. FIFO is a named pipe.

FIFO和PIPE基本差不多，但FIFO是命名的，一些没有亲缘关系的process能共享它。

Normally, opening a FIFO for read or write, it blocks until another process opens it for write or read. Write and read必须一一对应。

A read gets as much data as it requests or as much data as the FIFO has, whichever is less.

A write to a FIFO is atomic, as long as the write does not exceed the capacity of the FIFO. The capacity is at least 4k.

How to set flags.

writefd = open (FIFO1, O_WRONLY|O_ONOBLOCK,0);

但是pipe没有open函数

所以只能这样设定

flags= fcntl (fd, F_GETFL,0);

flag|=O_NONBLOCK;

fcntl =(fd,F_SETFL,flags);

下面的表很重要，要看清下面的前提操作和当前操作，主要比较了Blocking和O_NONBLOCK条件下的区别

Operation	Existing opens of pipe or FIFO	Blocking (default)	O_NONBLOCK set
Open FIFO for reading	FIFO open for writing	Returns OK	Returns OK
Open FIFO for reading	FIFO not open for writing	Blocks until FIFO is opened for writing	Returns OK
Open FIFO for writing	FIFO open for reading	Returns OK	Returns OK
Open FIFO for writing	FIFO not open for reading	Blocks until FIFO is opened for reading	Returns an error of ENXIO
Read empty pipe or FIFO	Pipe or FIFO open for writing	Blocked until there is data or the pipe or FIFO is closed for writing	Return an error of EAGAIN
Read empty pipe or FIFO	Pipe or FIFO not open for writing	Read returns 0 (EOF)	Read return 0 (EOF)
Write to pipe or FIFO	Pipe or FIFO open for reading	Return ok	Return ok
	Pipe or FIFO is full	Blocked until space is available, then write data	Returns an error of EAGAIN
	Pipe or FIFO not open for reading	SIGPIPE generated, write process terminated	Returns an error of EPIPE

离弦之ray的技术天空 2006-06-20 23:42 发表评论

Pipe

离弦之ray的技术天空 — Wed, 14 Jun 2006 12:14:00 GMT

父进程和子进程创建双向管道的实际步骤

创建管道 1(fd1[0] 和 fd1[1]) 和管道 2(fd2[0] 和 fd2[1])

Fork

父进程关闭管道 1 的读出端（ fd1[0]） [MS1]

父进程关闭管道 2 的写入端（ fd2[1] ）

子进程关闭管道 1 的写入端（ fd1[1] ）

子进程关闭管道 2 的读出端（ fd2[0] ）

下面是示例程序：

#include “unpipe.h”

void client(int, int) ,server(int, int);

int main(int argc, char* argv[])

{

int pipe1[2],pipe[2];

pid_t childpid;

Pipe(pipe1);

Pipe(pipe2);

if((childpid=fork())==0)

{

Close(pipe1[1]) ;

Close(pipe2[0]) ;

server(pipe1[0],pipe2[1]) ;

exit(0) ;

}

close(pipe1[0]) ;

close(pipe2[1]) ;

client(pipe2[0],pipe1[1]) ;

waitpid(childpid,NULL,0) ;

exit(0) ;

}

//////////////////client

void client(int readfd, int writefd)

{

size_t len;

ssize_t n;

char buff[MAXLINE];

fgets(buff,MAXLINET,stdin);

len = strlen(buff);

if(buff[len-1]==’\n’)

len--;

write(writefd,buff,len);

while((n=read(readfd,buff,MAXLINE))>0)

write(STDOUT_FILENO,buff,n);

}

///////////////////server

void server(int readfd, int writefd)

{

int fd;

ssize_t n;

char buff[MAXLINE+1];

if((n=read(readfd,buff,MAXLINE))==0)

err_quit(“end-of –file while reading pathname”);

if((fd =open(buff,O_RDONLY)<0)){

sprintf(buff+n,sizeof(buff)-n,”can’t open, %s\n”,strerror(errno));

n = strlen(buff);

write(writefd,buff,n);

}else{

While((n=read(fd,buff,MAXLINE))>0)

Write(writefd,buff,n);

Close(fd);

}

Properties of Pipe:

1) Pipes do not have a name. For this reason, the processes must share a parent process. This is the main drawback to pipes. However, pipes are treated as file descriptors, so the pipes remain open even after fork and exec.

2) Pipes do not distinguish between messages; they just read a fixed number of bytes. New line (\n) can be used to separate messages. A structure with a length field can be used for message containing binary data.

3) Pipes can also be used to get the output of a command or to provide input to a command

[MS1] 换句话说就是父进程对管道 1 只能写，以下可以依此类推。

离弦之ray的技术天空 2006-06-14 20:14 发表评论

IPC——Interprocess Communication

离弦之ray的技术天空 — Wed, 14 Jun 2006 12:07:00 GMT

要考试啦，一边复习，一边记录……

IPC 有两个功能 : Synchronization 和 Message Passing ，其中 message Passing 有下面几种形式 :Pipes, FIFOs, Message Queues, Shared Memory

File or Record Locking

int lockf (int fd, int function, long size) 其中 fd 是文件描述符 (file descripter) ； size 是锁定的大小 [offset, offset+size] ，如果 size=0, 就表示文件余下的部分。可以用 lseek() 去移动当前的 offset 。而其中的 function 参数有以下几种： F_ULOCK, F_LOCK, F_TEST, F_TLOCK

离弦之ray的技术天空 2006-06-14 20:07 发表评论