操作系统实验一 Linux基本环境及进程管理

操作系统实验一 Linux基本环境及进程管理

实验一 Linux基本环境

一、实验目的

（1）熟悉Linux下的基本操作，学会使用各种Shell命令去操作Linux，对Linux有一个感性认识。

（2）学会使用vi编辑器编辑简单的C语言程序，并能对其编译和调试。

二、实验学时

1学时

三、实验内容

（1） 以root用户身份登陆，并使用“ls”,“cat”“cd”等命令来实现基本的文件操作并观察Linux文件系统的特点；

（2） 使用vi编辑器编写一C程序，并用gcc命令进行编译和链接，并用a.out来进行输出结果。

四、背景知识

常用命令练习：

用root账号（超级用户）注册，注册成功出现#号（超级用户系统提示符,普通用户的系统提示符为$）。

1． 注销（退出）系统：logout 或exit

2．练习使用命令ls（注意Linux命令区分大小写。）

使用ls 按字母顺序列出当前目录中所有非隐藏文件；

使用ls –a按字母顺序列出当前目录中所有文件，包括隐藏文件

使用ls –l 查看当前目录所有文件包括当前目录和父目录，包括长度、拥有者和权限； 使用dir 查看当前目录内容

3．使用cd改变当前目录

cd .. 回到上层目录；

cd /home/mj 移动到用户mj的主目录；

cd – 移动到自己的主目录，适用于任何用户

4．pwd 显示当前目录绝对路径

5．建立目录mkdir

mkdir 目录名； mkdir /home/s2001/newdir

6．删除目录：rmdir；

7．复制文件cp：

cp file1 file2 将file1内容复制到目标文件file2中，目标文件得到新的生成日期和inode编号；（在linux里每个文件都有一个唯一的inode号）

8．移动文件或目录: mv

mv file1 file2 将文件名从file1变成file2。

9．删除文件rm

rm file1 删除file1而不提示确认；

rm –i file1 提示用户确认之后删除file1

10. 显示文件内容：more (分页显示);

操作系统实验一 Linux基本环境及进程管理

11. 显示文件：cat 文件名

12. 建立文件：cat >文件名，ctrl+d结束输入

使用编辑器vi 编辑文件

1. 进入linux的文本模式之后，在命令行键入vi filename.c 然后回车。下面作一些简单的解释：首先vi命令是打开vi编辑器。后面的filename.c是用户即将编辑的c文件名字，注意扩展名字是.c；当然，vi编辑器功能很强，可以用它来编辑其它格式的文件，比如汇编文件，其扩展名字是.s；也可以直接用vi打开一个新的未命名的文件，当保存的时候再给它命名，只是这样做不很方便。

2. 最基本的命令I ：当进入刚打开的文件时，不能写入信息，这时按一下键盘上的I键（insert），插入的意思，就可以进入编辑模式了。

3. a与i是相同的用法

4. 当文件编辑完后，需要保存退出，这时需要经过以下几个步骤：1）按一下键盘上的Esc 键；

2）键入冒号(：)，紧跟在冒号后面是wq（意思是保存并退出）。如果不想保存退出，则在第二步键入冒号之后，键入q ！（不带w，机尾部保存）

5. 退出vi编辑器的编辑模式之后，要对刚才编写的程序进行编译。

编译的命令是：gcc [-o outputfilename.out] filename.c，其中gcc是c的编译器。参数：filename.c 是要编译的源文件的名称，outputfilename表示输出文件名称，中括号表示括号内部的内容可输入也可以不输入（中括号本身不再命令行中出现）。如果不输入outputfilename.out，默认的输出文件是a.out 。

6. 最后一步是运行程序，方法如下：./outputfilename.out

实验二 进程管理

一、实验目的

1. 加深对进程概念的理解，明确进程和程序的区别。

2. 进一步认识并发执行的实质。

3. 分析进程争用资源的现象，学习解决进程互斥的方法

4. 了解Linux系统中进程通信的基本原理

二、实验学时

3学时

三、实验内容

1.进程的创建

编写一段程序，使用系统调用fork（）创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”；子进程分别显示字符“b”和字符“c”。试观察记录屏幕上的显示结果，并分析原因。

操作系统实验一 Linux基本环境及进程管理

实验指导：

<背景知识>

一、进程

UNIX中，进程既是一个独立拥有资源的基本单位，又是一个独立调度的基本单位。一个进程实体由若干个区（段）组成，包括程序区、数据区、栈区、共享存储区等。每个区又分为若干页，每个进程配置有唯一的进程控制块PCB，用于控制和管理进程。

PCB的数据结构如下：

1、进程表项（Process Table Entry）。包括一些最常用的核心数据：

进程标识符PID、用户标识符UID、进程状态、事件描述符、进程和U区在内存或外存的地址、软中断信号、计时域、进程的大小、偏置值nice、指向就绪队列中下一个PCB的指针P_Link、指向U区进程正文、数据及栈在内存区域的指针。

2、U区（U Area）。用于存放进程表项的一些扩充信息。

每一个进程都有一个私用的U区，其中含有：进程表项指针、真正用户标识符u-ruid(read user ID)、有效用户标识符u-euid(effective user ID)、用户文件描述符表、计时器、内部I/O参数、限制字段、差错字段、返回值、信号处理数组。

由于UNIX系统采用段页式存储管理，为了把段的起始虚地址变换为段在系统中的物理地址，便于实现区的共享，所以还有：

3、系统区表项。以存放各个段在物理存储器中的位置等信息。

系统把一个进程的虚地址空间划分为若干个连续的逻辑区，有正文区、数据区、栈区等。这些区是可被共享和保护的独立实体，多个进程可共享一个区。为了对区进行管理，核心中设置一个系统区表，各表项中记录了以下有关描述活动区的信息：

区的类型和大小、区的状态、区在物理存储器中的位置、引用计数、指向文件索引结点的指针。

4、进程区表

系统为每个进程配置了一张进程区表。表中，每一项记录一个区的起始虚地址及指向系统区表中对应的区表项。核心通过查找进程区表和系统区表，便可将区的逻辑地址变换为物理地址。

二、进程映像

UNIX系统中，进程是进程映像的执行过程，也就是正在执行的进程实体。它由三部分组成：

1、用户级上、下文。主要成分是用户程序；

2、寄存器上、下文。由CPU中的一些寄存器的内容组成，如PC，PSW，SP及通用寄存器等；

3、系统级上、下文。包括OS为管理进程所用的信息，有静态和动态之分。

三、所涉及的系统调用

fork( )

创建一个新进程。

系统调用格式：

pid=fork( )

参数定义：

int fork( )

fork( )返回值意义如下：

0：在子进程中，pid变量保存的fork( )返回值为0，表示当前进程是子进程。

>0：在父进程中，pid变量保存的fork( )返回值为子进程的id值（进程唯一标识符）。 -1：创建失败。

操作系统实验一 Linux基本环境及进程管理

如果fork( )调用成功，它向父进程返回子进程的PID，并向子进程返回0，即fork( )被调用了一次，但返回了两次。此时OS在内存中建立一个新进程，所建的新进程是调用fork( )父进程（parent process）的副本，称为子进程（child process）。子进程继承了父进程的许多特性，并具有与父进程完全相同的用户级上下文。父进程与子进程并发执行。

核心为fork( )完成以下操作：

（1）为新进程分配一进程表项和进程标识符

进入fork( )后，核心检查系统是否有足够的资源来建立一个新进程。若资源不足，则fork( )系统调用失败；否则，核心为新进程分配一进程表项和唯一的进程标识符。

（2）检查同时运行的进程数目

超过预先规定的最大数目时，fork( )系统调用失败。

（3）拷贝进程表项中的数据

将父进程的当前目录和所有已打开的数据拷贝到子进程表项中，并置进程的状态为“创建”状态。

（4）子进程继承父进程的所有文件

对父进程当前目录和所有已打开的文件表项中的引用计数加1。

（5）为子进程创建进程上、下文

进程创建结束，设子进程状态为“内存中就绪”并返回子进程的标识符。

（6）子进程执行

虽然父进程与子进程程序完全相同，但每个进程都有自己的程序计数器PC(注意子进程的PC开始位置)，然后根据pid变量保存的fork( )返回值的不同，执行了不同的分支语句。

四、参考程序

#include <stdio.h>

main( )

{

int p1,p2;

while((p1=fork( ))= = -1); /*创建子进程p1*/

if (p1= =0) putchar('b');

else

{

while((p2=fork( ))= = -1); /*创建子进程p2*/

if(p2= =0) putchar('c');

else putchar('a');

}

}

<运行结果>bca(有时会出现abc的任意的排列)

分析：从进程执行并发来看，输出abc的排列都是有可能的。

原因：fork()创建进程所需的时间虽然可能多于输出一个字符的时间，但各个进程的时间片的获得却不是一定是顺序的，所以输出abc的排列都是有可能的。

2.进程的控制

修改已编写的程序，将每个进程输出一个字符改为每个进程输出一句话，再观察程序执行时屏幕上出现的现象，并分析原因。

如果在程序中使用系统调用lockf（）来给每一个进程加锁，可以实现进程之间

操作系统实验一 Linux基本环境及进程管理

的互斥，观察并分析出现的现象。

实验指导：

一、所涉及的系统调用

lockf()

lockf(files,function,size):

用作锁定文件的某些段或者整个文件，本函数适用的头文件为：

#include<unistd.h>

参数定义：

int lockf(files,function,size)

int files,function;

long size;

其中：files是文件描述符：function是锁定和解锁；1表示锁定，0表示解锁。size是锁定和解锁的字节数，若用0，表示从文件的当前位置到文件尾。

二、参考程序

〈程序1〉

#include <stdio.h>

main( )

{

int p1,p2,i;

while((p1=fork( ))= = -1); /*创建子进程p1*/

if (p1= =0)

for(i=0;i<100;i++)

printf("daughter %d/n",i);

else

{

while((p2=fork( ))= = -1); /*创建子进程p2*/

if(p2= =0)

for(i=0;i<100;i++)

printf("son %d/n",i);

else

for(i=0;i<100;i++)

printf("parent %d/n",i);

}

}

〈运行结果〉

2、parent…

son…

daughter..

daughter..

或 parent…

son…

parent…

操作系统实验一 Linux基本环境及进程管理

daughter…等

分析：由于函数printf()输出的字符串之间不会被中断，因此,每个字符串内部的字符顺序输出时不变。但是 , 由于进程并发执行时的调度顺序和父子进程的抢占处理机问题，输出字符串的顺序和先后随着执行的不同而发生变化。这与打印单字符的结果相同。

〈程序2〉

#include<stdio.h>

#include<unistd.h>

main()

{

int p1,p2,i;

while((p1=fork())==-1);

if(p1==0)

{

lockf(1,1,0);

for(i=0;i<50;i++)

printf("child %d/n",i);

lockf(1,0,0);

}

else

{

while((p2=fork())==-1);

if(p2==0)

{

lockf(1,1,0);

for(i=0;i<50;i++)

printf("son %d/n",i);

lockf(1,0,0);

}

else

{

lockf(1,1,0);

for(i=0;i<50;i++)

printf("daughter %d/n",i);

lockf(1,0,0);

}

}

}

<运行结果〉

输出parent块,son块,grandchild块的顺序可能不同，但是每个块的输出过程不会被打断。 分析：因为上述程序执行时，lockf(1,1,0)锁定标准输出设备，lockf(1,0,0)解锁标准输出设备，在lockf(1,1,0)与lockf(1,0,0)中间的for循环输出不会被中断，加锁与不加锁效果不相同。

3.用fork( )创建一个进程，再调用exec( )用新的程序替换该子进程的内容；利用

操作系统实验一 Linux基本环境及进程管理

wait( )来控制进程执行顺序

实验指导

一、所涉及的系统调用

在UNIX/LINUX中fork( )是一个非常有用的系统调用，但在UNIX/LINUX中建立进程除了fork( )之外，也可用与fork( )配合使用的exec( )。

1、exec( )系列

系统调用exec( )系列，也可用于新程序的运行。fork( )只是将父进程的用户级上下文拷贝到新进程中，而exec( )系列可以将一个可执行的二进制文件覆盖在新进程的用户级上下文的存储空间上，以更改新进程的用户级上下文。exec( )系列中的系统调用都完成相同的功能，它们把一个新程序装入内存，来改变调用进程的执行代码，从而形成新进程。如果exec( )调用成功，调用进程将被覆盖，然后从新程序的入口开始执行，这样就产生了一个新进程，新进程的进程标识符id 与调用进程相同。

exec( )没有建立一个与调用进程并发的子进程，而是用新进程取代了原来进程。所以exec( )调用成功后，没有任何数据返回，这与fork( )不同。exec( )系列系统调用在UNIX系统库unistd.h中，共有execl、execlp、execle、execv、execvp五个，其基本功能相同，只是以不同的方式来给出参数。

一种是直接给出参数的指针，如：

int execl(path,arg0[,arg1,...argn],0);

char *path,*arg0,*arg1,...,*argn;

另一种是给出指向参数表的指针，如：

int execv(path,argv);

char *path,*argv[ ];

具体使用可参考有关书。

2、exec( )和fork( )联合使用

系统调用exec和fork( )联合使用能为程序开发提供有力支持。用fork( )建立子进程，然后在子进程中使用exec( )，这样就实现了父进程与一个与它完全不同子进程的并发执行。 一般，wait、exec联合使用的模型为：

int status;

............

if (fork( )= =0)

{

...........;

execl(...);

...........;

}

wait(&status);

3、wait（ ）

等待子进程运行结束。如果子进程没有完成，父进程一直等待。wait( )将调用进程挂起，直至其子进程因暂停或终止而发来软中断信号为止。如果在wait( )前已有子进程暂停或终止，则调用进程做适当处理后便返回。

系统调用格式：

int wait(status)

int *status;

其中，status是用户空间的地址。它的低8位反应子进程状态，为0表示子进程正常结束，

操作系统实验一 Linux基本环境及进程管理

非0则表示出现了各种各样的问题；高8位则带回了exit( )的返回值。exit( )返回值由系统给出。

核心对wait( )作以下处理：

（1）首先查找调用进程是否有子进程，若无，则返回出错码；

（2）若找到一处于“僵死状态”的子进程，则将子进程的执行时间加到父进程的执行时间上，并释放子进程的进程表项；

（3）若未找到处于“僵死状态”的子进程，则调用进程便在可被中断的优先级上睡眠，等待其子进程发来软中断信号时被唤醒。

4、exit（ ）

终止进程的执行。

系统调用格式：

void exit(status)

int status;

其中，status是返回给父进程的一个整数，以备查考。

为了及时回收进程所占用的资源并减少父进程的干预，UNIX/LINUX利用exit( )来实现进程的自我终止，通常父进程在创建子进程时，应在进程的末尾安排一条exit( )，使子进程自我终止。exit(0)表示进程正常终止，exit(1)表示进程运行有错，异常终止。

如果调用进程在执行exit( )时，其父进程正在等待它的终止，则父进程可立即得到其返回的整数。核心须为exit( )完成以下操作：

（1）关闭软中断

（2）回收资源

（3）写记帐信息

（4）置进程为“僵死状态”

二、参考程序

#include<stdio.h>

#include<unistd.h>

#include<stdlib.h>

main( )

{

int pid;

pid=fork( ); /*创建子进程*/

switch(pid)

{

case -1: /*创建失败*/

printf("fork fail!/n");

exit(1);

case 0: /*子进程*/

execl("/bin/ls","ls","-1",NULL);

printf("exec fail!/n");

exit(1);

default: /*父进程*/

wait(NULL); /*同步*/

printf("ls completed !/n");

, exit(0);

操作系统实验一 Linux基本环境及进程管理

}

}

三、运行结果

执行命令ls -l ，列出当前目录下所有文件和子目录；

ls completed!

四、分析原因

程序在调用fork( )建立一个子进程后，马上调用wait( )，使父进程在子进程结束之前，一直处于睡眠状态。子进程用exec( )装入命令ls ，exec( )后，子进程的代码被ls的代码取代，这时子进程的PC指向ls的第1条语句，开始执行ls的命令代码。

注意在这里wait( )给我们提供了一种实现进程同步的简单方法。

五、思考

（1）可执行文件加载时进行了哪些处理？

（2）什么是进程同步？wait( )是如何实现进程同步的？

4.编制一段程序，使其实现进程的软中断通信。

要求:使用系统调用fork（）创建两个子进程，再用系统调用signal（）让父进程捕捉键盘上来的中断信号（即按Del键）；当捕捉到中断信号后，父进程用系统调用kill（）向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止：

Child process 1 is killed by parent!

Child process 2 is killed by parent!

父进程等待两个子进程终止后，输出如下的信息后终止：

Parent process is killed!

实验指导

一、信号

1 、信号的基本概念

每个信号都对应一个正整数常量 ( 称为 signal number, 即信号编号。定义在系统头文件 <signal.h> 中 ) ， 代表同一用户的诸进程之间传送事先约定的信息的类型，用于通知某进程发生了某异常事件。每个进程在运行时，都要通过信号机制来检查是否有信号到达。若有， 便中断正在执行的程序，转向与该信号相对应的处理程序，以完成对该事件的处理；处理结束后再返回到原来的断点继续执行。实质上，信号机制是对中断机制的一 种模拟，故在早期的 UNIX 版本中又把它称为软中断。

信号与中断的相似点：

（ 1 ）采用了相同的异步通信方式；

（ 2 ）当检测出有信号或中断请求时，都暂停正在执行的程序而转去执行相应的处理程序； （ 3 ）都在处理完毕后返回到原来的断点；

（ 4 ）对信号或中断都可进行屏蔽。

信号与中断的区别：

（ 1 ）中断有优先级，而信号没有优先级，所有的信号都是平等的；

（ 2 ）信号处理程序是在用户态下运行的，而中断处理程序是在核心态下运行； （ 3 ）中断响应是及时的，而信号响应通常都有较大的时间延迟。

信号机制具有以下三方面的功能：

（ 1 ）发送信号。发送信号的程序用系统调用 kill( ) 实现；

操作系统实验一 Linux基本环境及进程管理

（ 2 ）预置对信号的处理方式。接收信号的程序用 signal( ) 来实现对处理方式的预置； （ 3 ）收受信号的进程按事先的规定完成对相应事件的处理。

2 、信号的发送

信号的发送，是指由发送进程把信号送到指定进程的信号域的某一位上。如果目标进程正在一个可被中断的优先级上睡眠，核心便将它唤醒，发送进程就此结束。一个进程可能在其信号域中有多个位被置位，代表有多种类型的信号到达，但对于一类信号，进程却只能记住其中的某一个。

进程用 kill( ) 向一个进程或一组进程发送一个信号。

3 、对信号的处理

当一个进程要进入或退出一个低优先级睡眠状态时，或一个进程即将从核心态返回用户态时，核心都要检查该进程是否已收到软中断。当进程处于核心态时，即使收到软中断也不予理睬；只有当它返回到用户态后，才处理软中断信号。对软中断信号的处理分三种情况进行： （ 1 ）如果进程收到的软中断是一个已决定要忽略的信号（ function=1 ），进程不做任何处理便立即返回；

（ 2 ）进程收到软中断后便退出（ function=0 ）；

（ 3 ）执行用户设置的软中断处理程序。

二、所涉及的中断调用

1 、 kill( )

系统调用格式

int kill(pid,sig)

参数定义

int pid,sig;

其中， pid 是一个或一组进程的标识符，参数 sig 是要发送的软中断信号。

（ 1 ） pid>0 时，核心将信号发送给进程 pid 。

（ 2 ） pid=0 时，核心将信号发送给与发送进程同组的所有进程。

（ 3 ） pid=-1 时，核心将信号发送给所有用户标识符真正等于发送进程的有效用户标识号的进程。

2 、 signal( )

预置对信号的处理方式，允许调用进程控制软中断信号。

系统调用格式

signal(sig,function)

头文件为

#include <signal.h>

参数定义

signal(sig,function)

int sig;

void (*func) ( )

其中 sig 用于指定信号的类型， sig 为 0 则表示没有收到任何信号，余者如下表：

操作系统实验一 Linux基本环境及进程管理

function ：在该进程中的一个函数地址，在核心返回用户态时，它以软中断信号的序号作为参数调用该函数，对除了信号 SIGKILL ， SIGTRAP 和 SIGPWR 以外的信号，核心自动地重新设置软中断信号处理程序的值为SIG_DFL ，一个进程不能捕获 SIGKILL 信号。 function 的解释如下：

（ 1 ） function=1 时，进程对 sig 类信号不予理睬，亦即屏蔽了该类信号；

（ 2 ） function=0 时，缺省值，进程在收到 sig 信号后应终止自己；

（ 3 ） function 为非 0 ，非 1 类整数时， function 的值即作为信号处理程序的指针。

三、参考程序

#include <stdio.h>

#include<stdlib.h>

#include <signal.h>

#include <unistd.h>

void waiting( ),stop( );

int wait_mark;

main( )

{

int p1,p2,stdout;

while((p1=fork( ))= =-1); /* 创建子进程 p1*/

if (p1>0)

{

while((p2=fork( ))= =-1); /* 创建子进程 p2*/

if(p2>0)

{

wait_mark=1;

signal(SIGINT,stop); /* 接收到 ^c 信号，转 stop*/

waiting( );

操作系统实验一 Linux基本环境及进程管理

kill(p1,16); /* 向 p1 发软中断信号 16*/

kill(p2,17); /* 向 p2 发软中断信号 17*/

wait(0); /* 同步 */

wait(0);

printf("Parent process is killed!/n");

exit(0);

}

else

{

wait_mark=1;

signal(17,stop); /* 接收到软中断信号 17 ，转 stop*/

waiting( );

lockf(1,1,0);

printf("Child process 2 is killed by parent!/n");

lockf(1,0,0);

exit(0);

}

}

else

{

wait_mark=1;

signal(16,stop); /* 接收到软中断信号 16 ，转 stop*/

waiting( );

lockf(1,1,0);

printf("Child process 1 is killed by parent!/n");

lockf(1,0,0);

exit(0);

}

}

void waiting( )

{

while(wait_mark!=0);

}

void stop( )

{

wait_mark=0;

}

四、运行结果

屏幕上无反应，按下ctrl+c (接收到SIGINT信号)后，显示 Parent process is killed!

五、分析原因

上述程序中， signal( ) 都放在一段程序的前面部位，而不是在其他接收信号处。这是因为 signal( ) 的执行只是为进程指定信号值 16 或 17 的作用，以及分配相应的与 stop( ) 过程链接的指针。因而， signal( ) 函数必须在程序前面部分执行。

本方法通信效率低，当通信数据量较大时一般不用此法。

操作系统实验一 Linux基本环境及进程管理

六、思考

1 、该程序段前面部分用了两个 wait(0) ，它们起什么作用？

2 、该程序段中每个进程退出时都用了语句 exit(0) ，为什么？

3 、为何预期的结果并未显示出？

4 、程序该如何修改才能得到正确结果？

5 、不修改程序如何得到期望的输出？

附加任务：在上面的任务1中，增加语句signal(SIGINT,SIG_IGN)和语句signal(SIGQUIT,SIG_IGN)，观察执行结果，并分析原因。这里，

signal(SIGINT,SIG_IGN)和signal(SIGQUIT,SIG_IGN)分别为忽略键信号以及忽略中断信号。

<程序>

#include<stdio.h>

#include<stdlib.h>

#include<signal.h>

#include<unistd.h>

int pid1,pid2;

int EndFlag=0;

int pf1=0;

int pf2=0;

void IntDelete()

{

kill(pid1,16);

kill(pid2,17);

EndFlag=1;

}

void Int1()

{

printf("child process 1 is killed !by parent\n");

exit(0);

}

void Int2()

{

printf("child process 2 is killed !by parent\n");

exit(0);

}

main()

{

int exitpid;

signal(SIGINT,SIG_IGN);

signal(SIGINT,SIG_IGN);

while((pid1=fork())==-1);

if(pid1==0)

操作系统实验一 Linux基本环境及进程管理

{

Printf(“p1\n”);

signal(SIGUSR1,Int1);

signal(16,SIG_IGN);

pause();

exit(0);

}

Else

{

While((pid2=fork())==-1);

If(pid2==0)

{

printf(“p2\n”);

signal(SIGUSR2,Int2);

signal(17,SIG_IGN);

pause();

exit(0);

}

Else

{

Printtf(“parent\n”);

signal(SIGINT,IntDelete);

waitpid(-1,&exitpid,0);

printf("parent process is killed! \n");

exit(0);

}

}

}

〈运行结果〉

请读者将上述程序输入计算机后，执行并观察。

〈分析〉由于忽略了终端与退出的信号，程序会一直保持阻塞状态而无法退出。

本文来源：https://www.bwwdw.com/article/7ji4.html