MIT_JOS_Lab5

Client

devfile_read

Server

serve_read

/lib/file.c

/fs/serv.c

call fsipc()

fsipc

type

fsipcbuf

permission

4G

USTACKTOP

DISKMAP+DISKSIZE

DISKMAP

UTEXT

fsreq

Normal User Stack

1024...

3GB IDE Disk Space

union Fsipc *fsreq

Program Data & Heap...

..........

0xeebef000

0xeebed000

0xd0000000

1024 x PGSIZE

0x10000000

0x0ffff000

0x00800000

opentab[MAXOPEN]

construct fsipcbuf

union Fsipc fsipcbuf

struct Fsreq_read

struct Fsret_read

char ret_buf[PGSIZE];

opentab[MAXOPEN]

struct OpenFile *o

uint32_t o_fileid;

struct File *o_file;

int o_mode;

struct Fd *o_fd;

int req_fileid;

size_t req_n;

look up

o->o_file

ret->ret_buf

req->req_n

o->o_fd->...

move result...

ipc_send(whom, r, pg, perm);

ipc_recv(NULL, dstva, NULL)

ipc_find_env(ENV_TYPE_FS)

ipc_send(fsenv, type, &fsipcbuf...

memmove(buf, fsipcbuf.readRet.ret_buf, r);

We must first understand a union: Fsipc , His role is to pass information between client Env and server Env, So we use the way of sharing pages in IPC, the virtual address of this page is 0x0ffff000. The client builds Fsipc, and the server obtains the request information from Fsipc. Fsipc can express multiple requests, its structure is as follows:

union Fsipc {
    struct Fsreq_open {
        char req_path[MAXPATHLEN];
        int req_omode;
    } open;
    struct Fsreq_set_size {
        int req_fileid;
        off_t req_size;
    } set_size;
    struct Fsreq_read {
        int req_fileid;
        size_t req_n;
    } read;
    struct Fsret_read {
        char ret_buf[PGSIZE];
    } readRet;
    struct Fsreq_write {
        int req_fileid;
        size_t req_n;
        char req_buf[PGSIZE - (sizeof(int) + sizeof(size_t))];
    } write;
    struct Fsreq_stat {
        int req_fileid;
    } stat;
    struct Fsret_stat {
        char ret_name[MAXNAMELEN];
        off_t ret_size;
        int ret_isdir;
    } statRet;
    struct Fsreq_flush {
        int req_fileid;
    } flush;
    struct Fsreq_remove {
        char req_path[MAXPATHLEN];
    } remove;

    // Ensure Fsipc is one page
    char _pad[PGSIZE];
};

Therefore, the process of client make a request is:

1. construct fsipcbuf
2. call fsipc()
3. send message to file system Env
4. receive the result information

The OpenFile structure is a mapping maintained by the server process. It maps a real file struct File and the file descriptor struct Fd opened by the user client. The struct Fd corresponding to each opened file is mapped to a physical page up to FILEEVA (0xd0000000). The server and the client process that opens the file share this physical page. When the client process communicates with the file system server, 0_fileid is used to specify the file to be operated.

struct OpenFile {
    uint32_t o_fileid;  // file id
    struct File *o_file;    // mapped descriptor for open file
    int o_mode;     // open mode
    struct Fd *o_fd;    // Fd page
};

The file system defaults to a maximum of 1024 files that can be opened at the same time, so there are 1024 strcut Openfiles, corresponding to 1024 physical pages up to 0xd0000000 in the server process address space, used to map these corresponding struct Fd.

struct Fd is a file descriptor used to represent the open file. Note that this descriptor is different from the inode on the disk. This descriptor will only be available for the open file. His main information is:

struct Fd {
    int fd_dev_id; // device ID, 
    off_t fd_offset;   // offset in the file block
    int fd_omode;   
    union {
        // File server files
        struct FdFile fd_file;
    };
};

For all open files, we maintain an OpenFile array[], For server Env, file operations are accessed through the index of OpenFile array[]. For the server, OpenFile array[] saved in the server Env's data segment.

Exercise 5

After understanding the above mechanism, the implementation of the code is relatively clear

int serve_read(envid_t envid, union Fsipc *ipc)
{
    struct Fsreq_read *req = &ipc->read;
    struct Fsret_read *ret = &ipc->readRet;
    struct OpenFile *o;
    int r;

    if (debug)
        cprintf("serve_read %08x %08x %08x\n", envid, req->req_fileid, req->req_n);
    // get the OpenFile struct
    if ((r = openfile_lookup(envid, req->req_fileid, &o)) != 0) {
        return r;
    }
    // from file read n blocks with offset to ret_buf
    if ((r = file_read(o->o_file, ret->ret_buf, req->req_n, o->o_fd->fd_offset)) > 0) {
        o->o_fd->fd_offset += r;
    }
    return r;
}

Exercise 6

Like other *nix systems, user applications on JOS uses a file descriptor to access a file, and it is created by sending open request to the file server. The file server uses struct OpenFile to record an opened file, and these records are saved in opentab[]. Before performing file operations like read or write, the file should be opened first..

int
serve_write(envid_t envid, struct Fsreq_write *req)
{
    struct OpenFile *o;
    int r;

    if (debug)
        cprintf("serve_write %08x %08x %08x\n", envid, req->req_fileid, req->req_n);

    if ((r = openfile_lookup(envid, req->req_fileid, &o)) != 0) {
        return r;
    }
    if ((r = file_write(o->o_file, req->req_buf, req->req_n, o->o_fd->fd_offset)) > 0) {
        o->o_fd->fd_offset += r;
    }
    return r;
}

devfile_write() prepares the write request, and sends it to the server. Here the request and response both need to be checked. The req_buf should never exceed PGSIZE - (sizeof(int) + sizeof(size_t)) as the definition of struct Fsreq_write indicates, and the response value should above 0.

static ssize_t devfile_write(struct Fd *fd, const void *buf, size_t n)
{
    int r;

    fsipcbuf.write.req_fileid = fd->fd_file.id;
    fsipcbuf.write.req_n = n;
    assert(n <= PGSIZE - (sizeof(int) + sizeof(size_t)));
    memmove(fsipcbuf.write.req_buf, buf, n);
    if ((r = fsipc(FSREQ_WRITE, NULL)) < 0)
        return r;
    assert(r <= n);
    return r;
}

Spawning Processes

spawn() in lib/spawn.c creates a new process, loads the user program from the file system, and then starts the process to run the program. spawn() is like fork() in UNIX followed immediately by exec().

1. Open prog program file from file system

   elf = (struct Elf*) elf_buf;
       if (readn(fd, elf_buf, sizeof(elf_buf)) != sizeof(elf_buf)
           || elf->e_magic != ELF_MAGIC) {
           close(fd);
           cprintf("elf magic %08x want %08x\n", elf->e_magic, ELF_MAGIC);
           return -E_NOT_EXEC;
       }
   

2. Call the system call sys_exofork() to create a new Env structure

   // Create new child environment
       if ((r = sys_exofork()) < 0)
           return r;
       child = r;
   

3. Call the system to call sys_env_set_trapframe() to set the Trapframe field of the new Env structure (this field contains register information).

   // Set up trap frame, including initial stack.
       child_tf = envs[ENVX(child)].env_tf;
       child_tf.tf_eip = elf->e_entry;
   
       if ((r = init_stack(child, argv, &child_tf.tf_esp)) < 0)
           return r;
   

4. According to the program herder in the ELF file, read the user program into the memory as Segment and map it to the specified linear address

   // Set up program segments as defined in ELF header.
       ph = (struct Proghdr*) (elf_buf + elf->e_phoff);
       for (i = 0; i < elf->e_phnum; i++, ph++) {
           if (ph->p_type != ELF_PROG_LOAD)
               continue;
           perm = PTE_P | PTE_U;
           if (ph->p_flags & ELF_PROG_FLAG_WRITE)
               perm |= PTE_W;
           if ((r = map_segment(child, ph->p_va, ph->p_memsz,
                        fd, ph->p_filesz, ph->p_offset, perm)) < 0)
               goto error;
       }
       close(fd);
       fd = -1;
   // Copy shared library state.
       if ((r = copy_shared_pages(child)) < 0)
           panic("copy_shared_pages: %e", r);
   
       child_tf.tf_eflags |= FL_IOPL_3;   // devious: see user/faultio.c
       if ((r = sys_env_set_trapframe(child, &child_tf)) < 0)
           panic("sys_env_set_trapframe: %e", r);
   

5. Call the system call sys_env_set_status() to set the new Env structure status to ENV_RUNNABLE.

   if ((r = sys_env_set_status(child, ENV_RUNNABLE)) < 0)
           panic("sys_env_set_status: %e", r);
   

Exercise 7

static int
sys_env_set_trapframe(envid_t envid, struct Trapframe *tf)
{
    struct Env *e;
    int r;

    if ((r = envid2env(envid, &e, 1)) != 0) {
        return r;
    }
    user_mem_assert(e, tf, sizeof(struct Trapframe), PTE_W);
    tf->tf_cs |= 3;
    tf->tf_ss |= 3;
    tf->tf_eflags |= FL_IF;
    tf->tf_eflags &= ~FL_IOPL_3;
    e->env_tf = *tf;
    return 0;
}

case SYS_env_set_trapframe:
    return sys_env_set_trapframe(a1, (struct Trapframe *)a2);

Sharing library state across fork and spawn

In Unix, the file system is very important, because a design concept of UNIX is that everything is a file.

We mentioned in the previous article that struct Fd is a file descriptor of an open file. This descriptor can describe various files. Usually the position of this descriptor in the virtual space is starting at FDTABLE(0xD0000000), In JOS there are MAXFD (currently 32) file descriptors at most the application can have open at once. Each file descriptor also has an optional "data page" in the region starting at FILEDATA ((FDTABLE + MAXFD*PGSIZE)), which devices can use if they choose.

We would like to share file descriptor state across fork and spawn, but file descriptor state is kept in user-space memory. For unmodified spawn() and fork(), we use the copy-on-write mechanism, the child process copies the mapping of the parent process, and then handles page faults when there are page faults. We will change fork to know that certain regions of memory are used by the "library operating system" and should always be shared. Rather than hard-code a list of regions somewhere, we will set an otherwise-unused bit in the page table entries (just like we did with the PTE_COW bit in fork).

We have added the PTE_SHARE bit to the page table permissions. If this bit is set, then this PTE corresponding physical page is shared in memory,

we change the duppage() :

Where the shared page is different from Copy_on_write, the shared page does not need to set the PTE_COW bit, indicating that the physical page is shared and does not need to be copied,

Exercise 8

if ((uvpt[pn] & PTE_SHARE) == PTE_SHARE) {
        if ((r = sys_page_map(parent_envid, va, envid, va, uvpt[pn] & PTE_SYSCALL)) != 0) {
            panic("duppage: %e", r);
        }
    }
    else if ((uvpt[pn] & PTE_W) == PTE_W || (uvpt[pn] & PTE_COW) == PTE_COW) {
        if ((r = sys_page_map(parent_envid, va, envid, va, PTE_COW | PTE_U | PTE_P)) != 0) {
            panic("duppage: %e", r);
        }
        if ((r = sys_page_map(parent_envid, va, parent_envid, va, PTE_COW | PTE_U | PTE_P)) != 0) {
            panic("duppage: %e", r);
        }
    } else {
        if ((r = sys_page_map(parent_envid, va, envid, va, PTE_U | PTE_P)) != 0) {
            panic("duppage: %e", r);
        }
    }

The keyboard interface

In Lab1, we have implemented the console's input and output ports and inline assembly code. Now, we need to add these to the system call, so that the user Env can read the console input and output.

Exercise 9

  // Handle keyboard and serial interrupts.
    // LAB 5: Your code here.
    if (tf->tf_trapno == IRQ_OFFSET+IRQ_KBD) {
        kbd_intr();
        return;
    }

    if (tf->tf_trapno == IRQ_OFFSET+IRQ_SERIAL) {
        serial_intr();
        return;
    }

The Shell

Unix OS treats everything as a file, and the console is no exception, in JOS ,Run make run-icode or make run-icode-nox. This will run your kernel and start user/icode. icode execs init, which will set up the console as file descriptors 0 and 1 (standard input and standard output). The experiment has implemented the IO redirection function, now we only need to redirect the file descriptors of the read file to standard input, which is file descriptors 0.

Exercise 10

// Open 't' for reading as file descriptor 0
// (which environments use as standard input).
// We can't open a file onto a particular descriptor,
// so open the file as 'fd',
// then check whether 'fd' is 0.
// If not, dup 'fd' onto file descriptor 0,
// then close the original 'fd'.
// LAB 5: Your code here.
if ((fd = open(t, O_RDONLY)) < 0) {
    cprintf("open %s for read: %e", t, fd);
    exit();
}
if (fd != 0) {
    dup(fd, 0);
    close(fd);
}

If the file opened from path t is not standard input, we only need to redirect. In fact, the idea of IO redirection is also very simple, mainly achieved by modifying the file descriptor:

// Make file descriptor 'newfdnum' a duplicate of file descriptor 'oldfdnum'.
// For instance, writing onto either file descriptor will affect the
// file and the file offset of the other.
// Closes any previously open file descriptor at 'newfdnum'.
// This is implemented using virtual memory tricks (of course!).
int
dup(int oldfdnum, int newfdnum)
{
    int r;
    char *ova, *nva;
    pte_t pte;
    struct Fd *oldfd, *newfd;

    if ((r = fd_lookup(oldfdnum, &oldfd)) < 0)
        return r;
    close(newfdnum);

    newfd = INDEX2FD(newfdnum);
    ova = fd2data(oldfd);
    nva = fd2data(newfd);

    if ((uvpd[PDX(ova)] & PTE_P) && (uvpt[PGNUM(ova)] & PTE_P))
        if ((r = sys_page_map(0, ova, 0, nva, uvpt[PGNUM(ova)] & PTE_SYSCALL)) < 0)
            goto err;
    if ((r = sys_page_map(0, oldfd, 0, newfd, uvpt[PGNUM(oldfd)] & PTE_SYSCALL)) < 0)
        goto err;

    return newfdnum;

err:
    sys_page_unmap(0, newfd);
    sys_page_unmap(0, nva);
    return r;
}

图片由于cnblogs的渲染问题导致格式错乱了，贴个地址， https://app.diagrams.net/?client=1&lightbox=1&edit=_blank

原文链接: https://www.cnblogs.com/wevolf/p/13329243.html

欢迎关注

微信关注下方公众号，第一时间获取干货硬货；公众号内回复【pdf】免费获取数百本计算机经典书籍;

也有高质量的技术群，里面有嵌入式、搜广推等BAT大佬

admin

0 0

生成海报