From 333f9110909723fec6fb5740f2829d85b138cd40 Mon Sep 17 00:00:00 2001 From: wyfcyx Date: Sun, 15 Oct 2023 07:27:52 +0000 Subject: [PATCH] deploy: 48e5c194f91a005de123c8e6e116d432bcef4a77 --- ch5/.lock | 0 ch5/SourceSerif4-Bold.ttf.woff2 | Bin 81320 -> 0 bytes ch5/SourceSerif4-It.ttf.woff2 | Bin 59860 -> 0 bytes ch5/SourceSerif4-Regular.ttf.woff2 | Bin 76180 -> 0 bytes ch5/ayu.css | 1 - ch5/dark.css | 1 - ch5/down-arrow.svg | 1 - ch5/help.html | 1 + ch5/implementors/core/clone/trait.Clone.js | 6 +- ch5/implementors/core/cmp/trait.Eq.js | 6 +- ch5/implementors/core/cmp/trait.Ord.js | 6 +- ch5/implementors/core/cmp/trait.PartialEq.js | 6 +- ch5/implementors/core/cmp/trait.PartialOrd.js | 6 +- ch5/implementors/core/convert/trait.From.js | 6 +- ch5/implementors/core/fmt/trait.Binary.js | 6 +- ch5/implementors/core/fmt/trait.Debug.js | 6 +- ch5/implementors/core/fmt/trait.LowerHex.js | 6 +- ch5/implementors/core/fmt/trait.Octal.js | 6 +- ch5/implementors/core/fmt/trait.UpperHex.js | 6 +- ch5/implementors/core/fmt/trait.Write.js | 6 +- ch5/implementors/core/hash/trait.Hash.js | 6 +- .../core/iter/traits/collect/trait.Extend.js | 6 +- .../iter/traits/collect/trait.FromIterator.js | 6 +- .../iter/traits/collect/trait.IntoIterator.js | 6 +- .../iter/traits/iterator/trait.Iterator.js | 6 +- ch5/implementors/core/marker/trait.Copy.js | 6 +- ch5/implementors/core/marker/trait.Freeze.js | 6 +- ch5/implementors/core/marker/trait.Send.js | 6 +- .../core/marker/trait.StructuralEq.js | 6 +- .../core/marker/trait.StructuralPartialEq.js | 6 +- ch5/implementors/core/marker/trait.Sync.js | 6 +- ch5/implementors/core/marker/trait.Unpin.js | 6 +- ch5/implementors/core/ops/arith/trait.Sub.js | 6 +- .../core/ops/arith/trait.SubAssign.js | 6 +- ch5/implementors/core/ops/bit/trait.BitAnd.js | 6 +- .../core/ops/bit/trait.BitAndAssign.js | 6 +- ch5/implementors/core/ops/bit/trait.BitOr.js | 6 +- .../core/ops/bit/trait.BitOrAssign.js | 6 +- ch5/implementors/core/ops/bit/trait.BitXor.js | 6 +- .../core/ops/bit/trait.BitXorAssign.js | 6 +- ch5/implementors/core/ops/bit/trait.Not.js | 6 +- .../core/ops/deref/trait.Deref.js | 6 +- ch5/implementors/core/ops/drop/trait.Drop.js | 6 +- .../panic/unwind_safe/trait.RefUnwindSafe.js | 6 +- .../panic/unwind_safe/trait.UnwindSafe.js | 6 +- .../lazy_static/trait.LazyStatic.js | 6 +- .../os/mm/address/trait.StepByOne.js | 6 +- .../frame_allocator/trait.FrameAllocator.js | 6 +- ch5/light.css | 1 - ch5/main.js | 8 - ch5/noscript.css | 1 - ch5/os/all.html | 2 +- ch5/os/board/constant.CLOCK_FREQ.html | 2 +- ch5/os/board/constant.MEMORY_END.html | 2 +- ch5/os/board/constant.MMIO.html | 2 +- ch5/os/board/index.html | 4 +- ch5/os/board/sidebar-items.js | 2 +- ch5/os/config/constant.KERNEL_HEAP_SIZE.html | 2 +- ch5/os/config/constant.KERNEL_STACK_SIZE.html | 2 +- ch5/os/config/constant.PAGE_SIZE.html | 2 +- ch5/os/config/constant.PAGE_SIZE_BITS.html | 2 +- ch5/os/config/constant.TRAMPOLINE.html | 2 +- ch5/os/config/constant.TRAP_CONTEXT.html | 2 +- ch5/os/config/constant.USER_STACK_SIZE.html | 2 +- ch5/os/config/index.html | 4 +- ch5/os/config/sidebar-items.js | 2 +- ch5/os/console/fn.print.html | 2 +- ch5/os/console/index.html | 4 +- ch5/os/console/sidebar-items.js | 2 +- ch5/os/console/struct.Stdout.html | 26 +- ch5/os/fn.clear_bss.html | 4 +- ch5/os/fn.rust_main.html | 6 +- ch5/os/index.html | 34 +- ch5/os/lang_items/fn.panic.html | 2 +- ch5/os/lang_items/index.html | 4 +- ch5/os/lang_items/sidebar-items.js | 2 +- ch5/os/loader/fn.get_app_data.html | 4 +- ch5/os/loader/fn.get_app_data_by_name.html | 4 +- ch5/os/loader/fn.get_num_app.html | 4 +- ch5/os/loader/fn.list_apps.html | 4 +- ch5/os/loader/index.html | 9 +- ch5/os/loader/sidebar-items.js | 2 +- ch5/os/loader/struct.APP_NAMES.html | 2935 +++++++++-------- ch5/os/macro.print.html | 9 +- ch5/os/macro.println.html | 9 +- ch5/os/mm/address/constant.PA_WIDTH_SV39.html | 4 +- .../mm/address/constant.PPN_WIDTH_SV39.html | 2 +- ch5/os/mm/address/constant.VA_WIDTH_SV39.html | 2 +- .../mm/address/constant.VPN_WIDTH_SV39.html | 2 +- ch5/os/mm/address/index.html | 12 +- ch5/os/mm/address/sidebar-items.js | 2 +- ch5/os/mm/address/struct.PhysAddr.html | 67 +- ch5/os/mm/address/struct.PhysPageNum.html | 57 +- ch5/os/mm/address/struct.SimpleRange.html | 44 +- .../address/struct.SimpleRangeIterator.html | 325 +- ch5/os/mm/address/struct.VirtAddr.html | 65 +- ch5/os/mm/address/struct.VirtPageNum.html | 57 +- ch5/os/mm/address/trait.StepByOne.html | 7 +- ch5/os/mm/address/type.VPNRange.html | 11 +- ch5/os/mm/fn.frame_alloc.html | 4 +- ch5/os/mm/fn.init.html | 4 +- ch5/os/mm/fn.remap_test.html | 4 +- ch5/os/mm/fn.translated_byte_buffer.html | 8 +- ch5/os/mm/fn.translated_refmut.html | 4 +- ch5/os/mm/fn.translated_str.html | 4 +- ch5/os/mm/frame_allocator/fn.frame_alloc.html | 4 +- .../fn.frame_allocator_test.html | 4 +- .../mm/frame_allocator/fn.frame_dealloc.html | 4 +- .../fn.init_frame_allocator.html | 4 +- ch5/os/mm/frame_allocator/index.html | 11 +- ch5/os/mm/frame_allocator/sidebar-items.js | 2 +- .../struct.FRAME_ALLOCATOR.html | 29 +- .../frame_allocator/struct.FrameTracker.html | 29 +- .../struct.StackFrameAllocator.html | 25 +- .../frame_allocator/trait.FrameAllocator.html | 11 +- .../type.FrameAllocatorImpl.html | 6 +- .../heap_allocator/fn.handle_alloc_error.html | 4 +- ch5/os/mm/heap_allocator/fn.heap_test.html | 2 +- ch5/os/mm/heap_allocator/fn.init_heap.html | 4 +- ch5/os/mm/heap_allocator/index.html | 8 +- ch5/os/mm/heap_allocator/sidebar-items.js | 2 +- .../heap_allocator/static.HEAP_ALLOCATOR.html | 4 +- .../mm/heap_allocator/static.HEAP_SPACE.html | 4 +- ch5/os/mm/index.html | 26 +- ch5/os/mm/memory_set/enum.MapType.html | 37 +- ch5/os/mm/memory_set/fn.ebss.html | 2 +- ch5/os/mm/memory_set/fn.edata.html | 2 +- ch5/os/mm/memory_set/fn.ekernel.html | 2 +- ch5/os/mm/memory_set/fn.erodata.html | 2 +- ch5/os/mm/memory_set/fn.etext.html | 2 +- ch5/os/mm/memory_set/fn.remap_test.html | 4 +- ch5/os/mm/memory_set/fn.sbss_with_stack.html | 2 +- ch5/os/mm/memory_set/fn.sdata.html | 2 +- ch5/os/mm/memory_set/fn.srodata.html | 2 +- ch5/os/mm/memory_set/fn.stext.html | 2 +- ch5/os/mm/memory_set/fn.strampoline.html | 2 +- ch5/os/mm/memory_set/index.html | 10 +- ch5/os/mm/memory_set/sidebar-items.js | 2 +- ch5/os/mm/memory_set/struct.KERNEL_SPACE.html | 27 +- ch5/os/mm/memory_set/struct.MapArea.html | 32 +- .../mm/memory_set/struct.MapPermission.html | 138 +- ch5/os/mm/memory_set/struct.MemorySet.html | 52 +- .../page_table/fn.translated_byte_buffer.html | 8 +- .../mm/page_table/fn.translated_refmut.html | 4 +- ch5/os/mm/page_table/fn.translated_str.html | 4 +- ch5/os/mm/page_table/index.html | 8 +- ch5/os/mm/page_table/sidebar-items.js | 2 +- ch5/os/mm/page_table/struct.PTEFlags.html | 128 +- ch5/os/mm/page_table/struct.PageTable.html | 27 +- .../mm/page_table/struct.PageTableEntry.html | 49 +- ch5/os/mm/sidebar-items.js | 2 +- ch5/os/mm/struct.FrameTracker.html | 29 +- ch5/os/mm/struct.KERNEL_SPACE.html | 27 +- ch5/os/mm/struct.MapPermission.html | 138 +- ch5/os/mm/struct.MemorySet.html | 52 +- ch5/os/mm/struct.PageTableEntry.html | 49 +- ch5/os/mm/struct.PhysAddr.html | 67 +- ch5/os/mm/struct.PhysPageNum.html | 57 +- ch5/os/mm/struct.VirtAddr.html | 65 +- ch5/os/mm/struct.VirtPageNum.html | 57 +- ch5/os/sbi/fn.console_getchar.html | 4 +- ch5/os/sbi/fn.console_putchar.html | 4 +- ch5/os/sbi/fn.set_timer.html | 4 +- ch5/os/sbi/fn.shutdown.html | 4 +- ch5/os/sbi/index.html | 8 +- ch5/os/sbi/sidebar-items.js | 2 +- ch5/os/sidebar-items.js | 2 +- ch5/os/sync/index.html | 8 +- ch5/os/sync/sidebar-items.js | 2 +- ch5/os/sync/struct.UPSafeCell.html | 34 +- ch5/os/sync/up/index.html | 7 +- ch5/os/sync/up/sidebar-items.js | 2 +- ch5/os/sync/up/struct.UPSafeCell.html | 34 +- ch5/os/syscall/constant.SYSCALL_EXEC.html | 2 +- ch5/os/syscall/constant.SYSCALL_EXIT.html | 2 +- ch5/os/syscall/constant.SYSCALL_FORK.html | 2 +- ch5/os/syscall/constant.SYSCALL_GETPID.html | 2 +- ch5/os/syscall/constant.SYSCALL_GET_TIME.html | 2 +- ch5/os/syscall/constant.SYSCALL_READ.html | 2 +- ch5/os/syscall/constant.SYSCALL_WAITPID.html | 2 +- ch5/os/syscall/constant.SYSCALL_WRITE.html | 2 +- ch5/os/syscall/constant.SYSCALL_YIELD.html | 2 +- ch5/os/syscall/fn.syscall.html | 4 +- ch5/os/syscall/fs/constant.FD_STDIN.html | 2 +- ch5/os/syscall/fs/constant.FD_STDOUT.html | 2 +- ch5/os/syscall/fs/fn.sys_read.html | 2 +- ch5/os/syscall/fs/fn.sys_write.html | 2 +- ch5/os/syscall/fs/index.html | 4 +- ch5/os/syscall/fs/sidebar-items.js | 2 +- ch5/os/syscall/index.html | 10 +- ch5/os/syscall/process/fn.sys_exec.html | 2 +- ch5/os/syscall/process/fn.sys_exit.html | 2 +- ch5/os/syscall/process/fn.sys_fork.html | 2 +- ch5/os/syscall/process/fn.sys_get_time.html | 2 +- ch5/os/syscall/process/fn.sys_getpid.html | 2 +- ch5/os/syscall/process/fn.sys_waitpid.html | 4 +- ch5/os/syscall/process/fn.sys_yield.html | 2 +- ch5/os/syscall/process/index.html | 5 +- ch5/os/syscall/process/sidebar-items.js | 2 +- ch5/os/syscall/sidebar-items.js | 2 +- ch5/os/task/constant.IDLE_PID.html | 4 +- ch5/os/task/context/index.html | 5 +- ch5/os/task/context/sidebar-items.js | 2 +- ch5/os/task/context/struct.TaskContext.html | 37 +- ch5/os/task/fn.add_initproc.html | 4 +- ch5/os/task/fn.add_task.html | 4 +- ch5/os/task/fn.current_task.html | 4 +- ch5/os/task/fn.current_trap_cx.html | 4 +- ch5/os/task/fn.current_user_token.html | 4 +- ch5/os/task/fn.exit_current_and_run_next.html | 4 +- ch5/os/task/fn.fetch_task.html | 4 +- ch5/os/task/fn.pid_alloc.html | 4 +- ch5/os/task/fn.run_tasks.html | 4 +- ch5/os/task/fn.schedule.html | 4 +- .../task/fn.suspend_current_and_run_next.html | 4 +- ch5/os/task/fn.take_current_task.html | 4 +- ch5/os/task/index.html | 38 +- ch5/os/task/manager/fn.add_task.html | 4 +- ch5/os/task/manager/fn.fetch_task.html | 4 +- ch5/os/task/manager/index.html | 7 +- ch5/os/task/manager/sidebar-items.js | 2 +- ch5/os/task/manager/struct.TASK_MANAGER.html | 27 +- ch5/os/task/manager/struct.TaskManager.html | 33 +- ch5/os/task/pid/fn.kernel_stack_position.html | 4 +- ch5/os/task/pid/fn.pid_alloc.html | 4 +- ch5/os/task/pid/index.html | 9 +- ch5/os/task/pid/sidebar-items.js | 2 +- ch5/os/task/pid/struct.KernelStack.html | 33 +- ch5/os/task/pid/struct.PID_ALLOCATOR.html | 27 +- ch5/os/task/pid/struct.PidAllocator.html | 31 +- ch5/os/task/pid/struct.PidHandle.html | 24 +- ch5/os/task/processor/fn.current_task.html | 4 +- ch5/os/task/processor/fn.current_trap_cx.html | 4 +- .../task/processor/fn.current_user_token.html | 4 +- ch5/os/task/processor/fn.run_tasks.html | 4 +- ch5/os/task/processor/fn.schedule.html | 4 +- .../task/processor/fn.take_current_task.html | 4 +- ch5/os/task/processor/index.html | 13 +- ch5/os/task/processor/sidebar-items.js | 2 +- ch5/os/task/processor/struct.PROCESSOR.html | 27 +- ch5/os/task/processor/struct.Processor.html | 37 +- ch5/os/task/sidebar-items.js | 2 +- ch5/os/task/struct.INITPROC.html | 27 +- ch5/os/task/struct.KernelStack.html | 33 +- ch5/os/task/struct.PidAllocator.html | 31 +- ch5/os/task/struct.PidHandle.html | 24 +- ch5/os/task/struct.Processor.html | 37 +- ch5/os/task/struct.TaskContext.html | 37 +- ch5/os/task/struct.TaskManager.html | 33 +- ch5/os/task/switch/fn.__switch.html | 5 +- ch5/os/task/switch/index.html | 4 +- ch5/os/task/switch/sidebar-items.js | 2 +- ch5/os/task/task/enum.TaskStatus.html | 34 +- ch5/os/task/task/index.html | 4 +- ch5/os/task/task/sidebar-items.js | 2 +- ch5/os/task/task/struct.TaskControlBlock.html | 23 +- .../task/struct.TaskControlBlockInner.html | 23 +- ch5/os/timer/constant.MSEC_PER_SEC.html | 2 +- ch5/os/timer/constant.TICKS_PER_SEC.html | 2 +- ch5/os/timer/fn.get_time.html | 4 +- ch5/os/timer/fn.get_time_ms.html | 4 +- ch5/os/timer/fn.set_next_trigger.html | 4 +- ch5/os/timer/index.html | 7 +- ch5/os/timer/sidebar-items.js | 2 +- ch5/os/trap/context/index.html | 5 +- ch5/os/trap/context/sidebar-items.js | 2 +- ch5/os/trap/context/struct.TrapContext.html | 49 +- ch5/os/trap/fn.enable_timer_interrupt.html | 4 +- ch5/os/trap/fn.init.html | 4 +- ch5/os/trap/fn.set_kernel_trap_entry.html | 2 +- ch5/os/trap/fn.set_user_trap_entry.html | 2 +- ch5/os/trap/fn.trap_from_kernel.html | 6 +- ch5/os/trap/fn.trap_handler.html | 6 +- ch5/os/trap/fn.trap_return.html | 6 +- ch5/os/trap/index.html | 21 +- ch5/os/trap/sidebar-items.js | 2 +- ch5/os/trap/struct.TrapContext.html | 49 +- ch5/rustdoc.css | 1 - ch5/search-index.js | 2 +- ch5/search.js | 1 - ch5/settings.css | 1 - ch5/settings.html | 2 +- ch5/settings.js | 11 - ch5/source-script.js | 1 - ch5/{source-files.js => src-files.js} | 4 +- ch5/src/os/boards/qemu.rs.html | 31 +- ch5/src/os/config.rs.html | 45 +- ch5/src/os/console.rs.html | 111 +- ch5/src/os/lang_items.rs.html | 67 +- ch5/src/os/loader.rs.html | 243 +- ch5/src/os/main.rs.html | 289 +- ch5/src/os/mm/address.rs.html | 1047 +++--- ch5/src/os/mm/frame_allocator.rs.html | 463 ++- ch5/src/os/mm/heap_allocator.rs.html | 173 +- ch5/src/os/mm/memory_set.rs.html | 1415 ++++---- ch5/src/os/mm/mod.rs.html | 103 +- ch5/src/os/mm/page_table.rs.html | 721 ++-- ch5/src/os/sbi.rs.html | 103 +- ch5/src/os/sync/mod.rs.html | 17 +- ch5/src/os/sync/up.rs.html | 107 +- ch5/src/os/syscall/fs.rs.html | 163 +- ch5/src/os/syscall/mod.rs.html | 159 +- ch5/src/os/syscall/process.rs.html | 329 +- ch5/src/os/task/context.rs.html | 115 +- ch5/src/os/task/manager.rs.html | 145 +- ch5/src/os/task/mod.rs.html | 439 ++- ch5/src/os/task/pid.rs.html | 385 ++- ch5/src/os/task/processor.rs.html | 337 +- ch5/src/os/task/switch.rs.html | 31 +- ch5/src/os/task/task.rs.html | 629 ++-- ch5/src/os/timer.rs.html | 73 +- ch5/src/os/trap/context.rs.html | 181 +- ch5/src/os/trap/mod.rs.html | 471 ++- .../COPYRIGHT-23e9bde6c69aea69.txt} | 4 + .../FiraSans-LICENSE-db4b642586e02d97.txt} | 4 + .../FiraSans-Medium-8f9a781e4970d388.woff2} | Bin .../FiraSans-Regular-018c141bf0843ffd.woff2} | Bin .../LICENSE-APACHE-b91fa81cba47b86a.txt} | 0 .../LICENSE-MIT-65090b722b3f6c56.txt} | 0 ...numBarunGothic-0f09457c7a19b7c6.ttf.woff2} | Bin ...mBarunGothic-LICENSE-18c5adf4b52b4041.txt} | 4 + ...urceCodePro-It-1cc31594bf4f1f79.ttf.woff2} | Bin ...ourceCodePro-LICENSE-d180d465a756484a.txt} | 4 + ...odePro-Regular-562dcc5011b6de7d.ttf.woff2} | Bin ...dePro-Semibold-d899c5a5c4aeb14a.ttf.woff2} | Bin ...urceSerif4-Bold-a2c9cd1067f8b328.ttf.woff2 | Bin 0 -> 81540 bytes ...SourceSerif4-It-acdfaf1a8af734b1.ttf.woff2 | Bin 0 -> 59716 bytes .../SourceSerif4-LICENSE-3bb119e13b1258b7.md} | 5 + ...eSerif4-Regular-46f98efaafac5295.ttf.woff2 | Bin 0 -> 76260 bytes .../clipboard-7571035ce49a181d.svg} | 0 .../favicon-16x16-8b506e7a72182f1c.png} | Bin .../favicon-2c020d218678b618.svg} | 0 .../favicon-32x32-422f7d1d52889060.png} | Bin ch5/static.files/main-c5bd66d33317d69f.js | 12 + .../normalize-76eba96aa4d2e634.css} | 0 .../noscript-5d8b3c7633ad77ba.css | 1 + .../rust-logo-151179464ae7ed46.svg} | 0 ch5/static.files/rustdoc-fa3bb1812debf86c.css | 10 + .../scrape-examples-ef1e698c1d417c0c.js | 1 + ch5/static.files/search-5f5ec5419eadd0c9.js | 5 + ch5/static.files/settings-74424d7eec62a23e.js | 17 + .../src-script-3280b574d94e47b4.js | 1 + ch5/static.files/storage-fec3eaa3851e447d.js | 1 + ch5/static.files/wheel-7b819b6101059cd0.svg | 1 + ch5/storage.js | 1 - ch5/toggle-minus.svg | 1 - ch5/toggle-plus.svg | 1 - ch5/wheel.svg | 1 - 348 files changed, 7493 insertions(+), 7451 deletions(-) mode change 100755 => 100644 ch5/.lock delete mode 100644 ch5/SourceSerif4-Bold.ttf.woff2 delete mode 100644 ch5/SourceSerif4-It.ttf.woff2 delete mode 100644 ch5/SourceSerif4-Regular.ttf.woff2 delete mode 100644 ch5/ayu.css delete mode 100644 ch5/dark.css delete mode 100644 ch5/down-arrow.svg create mode 100644 ch5/help.html delete mode 100644 ch5/light.css delete mode 100644 ch5/main.js delete mode 100644 ch5/noscript.css delete mode 100644 ch5/rustdoc.css delete mode 100644 ch5/search.js delete mode 100644 ch5/settings.css delete mode 100644 ch5/settings.js delete mode 100644 ch5/source-script.js rename ch5/{source-files.js => src-files.js} (88%) rename ch5/{COPYRIGHT.txt => static.files/COPYRIGHT-23e9bde6c69aea69.txt} (97%) rename ch5/{FiraSans-LICENSE.txt => static.files/FiraSans-LICENSE-db4b642586e02d97.txt} (99%) rename ch5/{FiraSans-Medium.woff2 => static.files/FiraSans-Medium-8f9a781e4970d388.woff2} (100%) rename ch5/{FiraSans-Regular.woff2 => static.files/FiraSans-Regular-018c141bf0843ffd.woff2} (100%) rename ch5/{LICENSE-APACHE.txt => static.files/LICENSE-APACHE-b91fa81cba47b86a.txt} (100%) rename ch5/{LICENSE-MIT.txt => static.files/LICENSE-MIT-65090b722b3f6c56.txt} (100%) rename ch5/{NanumBarunGothic.ttf.woff2 => static.files/NanumBarunGothic-0f09457c7a19b7c6.ttf.woff2} (100%) rename ch5/{NanumBarunGothic-LICENSE.txt => static.files/NanumBarunGothic-LICENSE-18c5adf4b52b4041.txt} (99%) rename ch5/{SourceCodePro-It.ttf.woff2 => static.files/SourceCodePro-It-1cc31594bf4f1f79.ttf.woff2} (100%) rename ch5/{SourceCodePro-LICENSE.txt => static.files/SourceCodePro-LICENSE-d180d465a756484a.txt} (99%) rename ch5/{SourceCodePro-Regular.ttf.woff2 => static.files/SourceCodePro-Regular-562dcc5011b6de7d.ttf.woff2} (100%) rename ch5/{SourceCodePro-Semibold.ttf.woff2 => static.files/SourceCodePro-Semibold-d899c5a5c4aeb14a.ttf.woff2} (100%) create mode 100644 ch5/static.files/SourceSerif4-Bold-a2c9cd1067f8b328.ttf.woff2 create mode 100644 ch5/static.files/SourceSerif4-It-acdfaf1a8af734b1.ttf.woff2 rename ch5/{SourceSerif4-LICENSE.md => static.files/SourceSerif4-LICENSE-3bb119e13b1258b7.md} (94%) create mode 100644 ch5/static.files/SourceSerif4-Regular-46f98efaafac5295.ttf.woff2 rename ch5/{clipboard.svg => static.files/clipboard-7571035ce49a181d.svg} (100%) rename ch5/{favicon-16x16.png => static.files/favicon-16x16-8b506e7a72182f1c.png} (100%) rename ch5/{favicon.svg => static.files/favicon-2c020d218678b618.svg} (100%) rename ch5/{favicon-32x32.png => static.files/favicon-32x32-422f7d1d52889060.png} (100%) create mode 100644 ch5/static.files/main-c5bd66d33317d69f.js rename ch5/{normalize.css => static.files/normalize-76eba96aa4d2e634.css} (100%) create mode 100644 ch5/static.files/noscript-5d8b3c7633ad77ba.css rename ch5/{rust-logo.svg => static.files/rust-logo-151179464ae7ed46.svg} (100%) create mode 100644 ch5/static.files/rustdoc-fa3bb1812debf86c.css create mode 100644 ch5/static.files/scrape-examples-ef1e698c1d417c0c.js create mode 100644 ch5/static.files/search-5f5ec5419eadd0c9.js create mode 100644 ch5/static.files/settings-74424d7eec62a23e.js create mode 100644 ch5/static.files/src-script-3280b574d94e47b4.js create mode 100644 ch5/static.files/storage-fec3eaa3851e447d.js create mode 100644 ch5/static.files/wheel-7b819b6101059cd0.svg delete mode 100644 ch5/storage.js delete mode 100644 ch5/toggle-minus.svg delete mode 100644 ch5/toggle-plus.svg delete mode 100644 ch5/wheel.svg diff --git a/ch5/.lock b/ch5/.lock old mode 100755 new mode 100644 diff --git a/ch5/SourceSerif4-Bold.ttf.woff2 b/ch5/SourceSerif4-Bold.ttf.woff2 deleted file mode 100644 index db57d21455c94e80aa7cca25cac803a08e1b01ec..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 81320 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 N>ZPvCW|kqQ1ONsnDE9yW diff --git a/ch5/SourceSerif4-It.ttf.woff2 b/ch5/SourceSerif4-It.ttf.woff2 deleted file mode 100644 index 1cbc021a3aa22e1469542d531e9115fb78d497ec..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 59860 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 diff --git a/ch5/SourceSerif4-Regular.ttf.woff2 b/ch5/SourceSerif4-Regular.ttf.woff2 deleted file mode 100644 index 2db73fe2b49e8cfcaaf1d5311a610e730b8ed502..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 76180 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 diff --git a/ch5/ayu.css b/ch5/ayu.css deleted file mode 100644 index f98b3417..00000000 --- a/ch5/ayu.css +++ /dev/null @@ -1 +0,0 @@ - :root{--main-background-color:#0f1419;--main-color:#c5c5c5;--settings-input-color:#ffb454;--sidebar-background-color:#14191f;--sidebar-background-color-hover:rgba(70,70,70,0.33);--code-block-background-color:#191f26;--scrollbar-track-background-color:transparent;--scrollbar-thumb-background-color:#5c6773;--scrollbar-color:#5c6773 #24292f;--headings-border-bottom-color:#5c6773;}.slider{background-color:#ccc;}.slider:before{background-color:white;}input:focus+.slider{box-shadow:0 0 0 2px #0a84ff,0 0 0 6px rgba(10,132,255,0.3);}h1,h2,h3,h4{color:white;}h1.fqn a{color:#fff;}h4{border:none;}.in-band{background-color:#0f1419;}.docblock code{color:#ffb454;}.code-header{color:#e6e1cf;}.docblock pre>code,pre>code{color:#e6e1cf;}span code{color:#e6e1cf;}.docblock a>code{color:#39AFD7 !important;}pre,.rustdoc.source .example-wrap{color:#e6e1cf;}.rust-logo{filter:drop-shadow(1px 0 0px #fff) drop-shadow(0 1px 0 #fff) drop-shadow(-1px 0 0 #fff) drop-shadow(0 -1px 0 #fff);}.sidebar .current,.sidebar a:hover{background-color:transparent;color:#ffb44c;}.sidebar-elems .location{color:#ff7733;}.line-numbers span{color:#5c6773;}.line-numbers .line-highlighted{color:#708090;background-color:rgba(255,236,164,0.06);padding-right:4px;border-right:1px solid #ffb44c;}.docblock table td,.docblock table th{border-color:#5c6773;}.search-results a:hover{background-color:#777;}.search-results a:focus{color:#000 !important;background-color:#c6afb3;}.search-results a{color:#0096cf;}.search-results a div.desc{color:#c5c5c5;}.content .item-info::before{color:#ccc;}.content span.foreigntype,.content a.foreigntype{color:#ffa0a5;}.content span.union,.content a.union{color:#ffa0a5;}.content span.constant,.content a.constant,.content span.static,.content a.static{color:#39AFD7;}.content span.primitive,.content a.primitive{color:#ffa0a5;}.content span.traitalias,.content a.traitalias{color:#39AFD7;}.content span.keyword,.content a.keyword{color:#39AFD7;}.content span.externcrate,.content span.mod,.content a.mod{color:#39AFD7;}.content span.struct,.content a.struct{color:#ffa0a5;}.content span.enum,.content a.enum{color:#ffa0a5;}.content span.trait,.content a.trait{color:#39AFD7;}.content span.type,.content a.type{color:#39AFD7;}.content span.type,.content a.type,.block a.current.type{color:#39AFD7;}.content span.associatedtype,.content a.associatedtype,.block a.current.associatedtype{color:#39AFD7;}.content span.fn,.content a.fn,.content span.method,.content a.method,.content span.tymethod,.content a.tymethod,.content .fnname{color:#fdd687;}.content span.attr,.content a.attr,.content span.derive,.content a.derive,.content span.macro,.content a.macro{color:#a37acc;}.sidebar a{color:#53b1db;}.sidebar a.current.type{color:#53b1db;}.sidebar a.current.associatedtype{color:#53b1db;}pre.rust .comment{color:#788797;}pre.rust .doccomment{color:#a1ac88;}nav.main .current{border-top-color:#5c6773;border-bottom-color:#5c6773;}nav.main .separator{border:1px solid #5c6773;}a{color:#39AFD7;}.sidebar h2 a,.sidebar h3 a{color:white;}.search-results a{color:#0096cf;}body.source .example-wrap pre.rust a{background:#333;}details.rustdoc-toggle>summary.hideme>span,details.rustdoc-toggle>summary::before{color:#999;}details.rustdoc-toggle>summary::before{filter:invert(100%);}#crate-search,.search-input{background-color:#141920;border-color:#424c57;}#crate-search{border-color:#424c57 !important;}.search-input{color:#ffffff;}.module-item .stab,.import-item .stab{color:#000;}.stab.empty-impl{}.stab.must_implement{}.stab.unstable,.stab.deprecated,.stab.portability,.stab.empty-impl,.stab.must_implement{color:#c5c5c5;background:#314559 !important;border-style:none !important;border-radius:4px;padding:3px 6px 3px 6px;}.stab.portability>code{color:#e6e1cf;background:none;}.rightside,.out-of-band{color:grey;}.result-name .primitive>i,.result-name .keyword>i{color:#788797;}.line-numbers :target{background-color:transparent;}pre.rust .number,pre.rust .string{color:#b8cc52;}pre.rust .kw,pre.rust .kw-2,pre.rust .prelude-ty,pre.rust .bool-val,pre.rust .prelude-val,pre.rust .op,pre.rust .lifetime{color:#ff7733;}pre.rust .macro,pre.rust .macro-nonterminal{color:#a37acc;}pre.rust .question-mark{color:#ff9011;}pre.rust .self{color:#36a3d9;font-style:italic;}pre.rust .attribute{color:#e6e1cf;}pre.rust .attribute .ident,pre.rust .attribute .op{color:#e6e1cf;}.example-wrap>pre.line-number{color:#5c67736e;border:none;}a.test-arrow{font-size:100%;color:#788797;border-radius:4px;background-color:rgba(57,175,215,0.09);}a.test-arrow:hover{background-color:rgba(57,175,215,0.368);color:#c5c5c5;}.toggle-label,.code-attribute{color:#999;}:target{background:rgba(255,236,164,0.06);border-right:3px solid rgba(255,180,76,0.85);}pre.compile_fail{border-left:2px solid rgba(255,0,0,.4);}pre.compile_fail:hover,.information:hover+pre.compile_fail{border-left:2px solid #f00;}pre.should_panic{border-left:2px solid rgba(255,0,0,.4);}pre.should_panic:hover,.information:hover+pre.should_panic{border-left:2px solid #f00;}pre.ignore{border-left:2px solid rgba(255,142,0,.6);}pre.ignore:hover,.information:hover+pre.ignore{border-left:2px solid #ff9200;}.tooltip.compile_fail{color:rgba(255,0,0,.5);}.information>.compile_fail:hover{color:#f00;}.tooltip.should_panic{color:rgba(255,0,0,.5);}.information>.should_panic:hover{color:#f00;}.tooltip.ignore{color:rgba(255,142,0,.6);}.information>.ignore:hover{color:#ff9200;}.search-failed a{color:#39AFD7;}.tooltip::after{background-color:#314559;color:#c5c5c5;border:1px solid #5c6773;}.tooltip::before{border-color:transparent #314559 transparent transparent;}.notable-traits-tooltiptext{background-color:#314559;border-color:#5c6773;}.notable-traits-tooltiptext .notable{border-bottom-color:#5c6773;}#titles>button.selected{background-color:#141920 !important;border-bottom:1px solid #ffb44c !important;border-top:none;}#titles>button:not(.selected){background-color:transparent !important;border:none;}#titles>button:hover{border-bottom:1px solid rgba(242,151,24,0.3);}#titles>button>div.count{color:#888;}.search-input:focus{}.content span.attr,.content a.attr,.block a.current.attr,.content span.derive,.content a.derive,.block a.current.derive,.content span.macro,.content a.macro,.block a.current.macro{}.content span.struct,.content a.struct,.block a.current.struct{}#titles>button:hover,#titles>button.selected{}.content span.typedef,.content a.typedef,.block a.current.typedef{}.content span.union,.content a.union,.block a.current.union{}pre.rust .lifetime{}.stab.unstable{}h2,h3:not(.impl):not(.method):not(.type):not(.tymethod),h4:not(.method):not(.type):not(.tymethod){}.content span.enum,.content a.enum,.block a.current.enum{}.content span.constant,.content a.constant,.block a.current.constant,.content span.static,.content a.static,.block a.current.static{}.content span.keyword,.content a.keyword,.block a.current.keyword{}pre.rust .comment{}.content span.traitalias,.content a.traitalias,.block a.current.traitalias{}.content span.fn,.content a.fn,.block a.current.fn,.content span.method,.content a.method,.block a.current.method,.content span.tymethod,.content a.tymethod,.block a.current.tymethod,.content .fnname{}pre.rust .kw{}pre.rust .self,pre.rust .bool-val,pre.rust .prelude-val,pre.rust .attribute,pre.rust .attribute .ident{}.content span.foreigntype,.content a.foreigntype,.block a.current.foreigntype{}pre.rust .doccomment{}.stab.deprecated{}.content a.attr,.content a.derive,.content a.macro{}.stab.portability{}.content span.primitive,.content a.primitive,.block a.current.primitive{}.content span.externcrate,.content span.mod,.content a.mod,.block a.current.mod{}pre.rust .kw-2,pre.rust .prelude-ty{}.content span.trait,.content a.trait,.block a.current.trait{}.search-results a:focus span{}a.result-trait:focus{}a.result-traitalias:focus{}a.result-mod:focus,a.result-externcrate:focus{}a.result-mod:focus{}a.result-externcrate:focus{}a.result-enum:focus{}a.result-struct:focus{}a.result-union:focus{}a.result-fn:focus,a.result-method:focus,a.result-tymethod:focus{}a.result-type:focus{}a.result-associatedtype:focus{}a.result-foreigntype:focus{}a.result-attr:focus,a.result-derive:focus,a.result-macro:focus{}a.result-constant:focus,a.result-static:focus{}a.result-primitive:focus{}a.result-keyword:focus{}.sidebar a.current.enum{}.sidebar a.current.struct{}.sidebar a.current.foreigntype{}.sidebar a.current.attr,.sidebar a.current.derive,.sidebar a.current.macro{}.sidebar a.current.union{}.sidebar a.current.constant .sidebar a.current.static{}.sidebar a.current.primitive{}.sidebar a.current.externcrate .sidebar a.current.mod{}.sidebar a.current.trait{}.sidebar a.current.traitalias{}.sidebar a.current.fn,.sidebar a.current.method,.sidebar a.current.tymethod{}.sidebar a.current.keyword{}@media (max-width:700px){.sidebar-elems{border-right-color:#5c6773;}}kbd{color:#c5c5c5;background-color:#314559;border-color:#5c6773;border-bottom-color:#5c6773;box-shadow:inset 0 -1px 0 #5c6773;}#settings-menu>a,#help-button>button{border-color:#5c6773;background-color:#0f1419;color:#fff;}#settings-menu>a img{filter:invert(100);}.popover,.popover::before,#help-button span.top,#help-button span.bottom{border-color:#5c6773;}#copy-path{color:#fff;}#copy-path>img{filter:invert(70%);}#copy-path:hover>img{filter:invert(100%);}#settings-menu>a:hover,#settings-menu>a:focus,#help-button>button:hover,#help-button>button:focus{border-color:#e0e0e0;}#theme-choices{border-color:#5c6773;background-color:#0f1419;}#theme-choices>button:not(:first-child){border-top-color:#5c6773;}#theme-choices>button:hover,#theme-choices>button:focus{background-color:rgba(110,110,110,0.33);}.search-results .result-name span.alias{color:#c5c5c5;}.search-results .result-name span.grey{color:#999;}#source-sidebar>.title{color:#fff;border-bottom-color:#5c6773;}#source-sidebar div.files>a:hover,details.dir-entry summary:hover,#source-sidebar div.files>a:focus,details.dir-entry summary:focus{background-color:#14191f;color:#ffb44c;}#source-sidebar div.files>a.selected{background-color:#14191f;color:#ffb44c;}.scraped-example-list .scrape-help{border-color:#aaa;color:#eee;}.scraped-example-list .scrape-help:hover{border-color:white;color:white;}.more-examples-toggle summary,.more-examples-toggle .hide-more{color:#999;}.scraped-example .example-wrap .rust span.highlight{background:rgb(91,59,1);}.scraped-example .example-wrap .rust span.highlight.focus{background:rgb(124,75,15);}.scraped-example:not(.expanded) .code-wrapper:before{background:linear-gradient(to bottom,rgba(15,20,25,1),rgba(15,20,25,0));}.scraped-example:not(.expanded) .code-wrapper:after{background:linear-gradient(to top,rgba(15,20,25,1),rgba(15,20,25,0));}.toggle-line-inner{background:#999;}.toggle-line:hover .toggle-line-inner{background:#c5c5c5;} \ No newline at end of file diff --git a/ch5/dark.css b/ch5/dark.css deleted file mode 100644 index 242423d0..00000000 --- a/ch5/dark.css +++ /dev/null @@ -1 +0,0 @@ -:root{--main-background-color:#353535;--main-color:#ddd;--settings-input-color:#2196f3;--sidebar-background-color:#505050;--sidebar-background-color-hover:#676767;--code-block-background-color:#2A2A2A;--scrollbar-track-background-color:#717171;--scrollbar-thumb-background-color:rgba(32,34,37,.6);--scrollbar-color:rgba(32,34,37,.6) #5a5a5a;--headings-border-bottom-color:#d2d2d2;}.slider{background-color:#ccc;}.slider:before{background-color:white;}input:focus+.slider{box-shadow:0 0 0 2px #0a84ff,0 0 0 6px rgba(10,132,255,0.3);}.in-band{background-color:#353535;}.rust-logo{filter:drop-shadow(1px 0 0px #fff) drop-shadow(0 1px 0 #fff) drop-shadow(-1px 0 0 #fff) drop-shadow(0 -1px 0 #fff)}.sidebar .current,.sidebar a:hover{background:#444;}.line-numbers span{color:#3B91E2;}.line-numbers .line-highlighted{background-color:#0a042f !important;}.docblock table td,.docblock table th{border-color:#ddd;}.search-results a:hover{background-color:#777;}.search-results a:focus{color:#eee !important;background-color:#616161;}.search-results a:focus span{color:#eee !important;}a.result-trait:focus{background-color:#013191;}a.result-traitalias:focus{background-color:#013191;}a.result-mod:focus,a.result-externcrate:focus{background-color:#884719;}a.result-enum:focus{background-color:#194e9f;}a.result-struct:focus{background-color:#194e9f;}a.result-union:focus{background-color:#194e9f;}a.result-fn:focus,a.result-method:focus,a.result-tymethod:focus{background-color:#4950ed;}a.result-type:focus{background-color:#194e9f;}a.result-associatedtype:focus{background-color:#884719;}a.result-foreigntype:focus{background-color:#194e9f;}a.result-attr:focus,a.result-derive:focus,a.result-macro:focus{background-color:#217d1c;}a.result-constant:focus,a.result-static:focus{background-color:#884719;}a.result-primitive:focus{background-color:#194e9f;}a.result-keyword:focus{background-color:#884719;}.content .item-info::before{color:#ccc;}.content span.enum,.content a.enum,.block a.current.enum{color:#2dbfb8;}.content span.struct,.content a.struct,.block a.current.struct{color:#2dbfb8;}.content span.type,.content a.type,.block a.current.type{color:#2dbfb8;}.content span.associatedtype,.content a.associatedtype,.block a.current.associatedtype{color:#D2991D;}.content span.foreigntype,.content a.foreigntype,.block a.current.foreigntype{color:#2dbfb8;}.content span.attr,.content a.attr,.block a.current.attr,.content span.derive,.content a.derive,.block a.current.derive,.content span.macro,.content a.macro,.block a.current.macro{color:#09bd00;}.content span.union,.content a.union,.block a.current.union{color:#2dbfb8;}.content span.constant,.content a.constant,.block a.current.constant,.content span.static,.content a.static,.block a.current.static{color:#D2991D;}.content span.primitive,.content a.primitive,.block a.current.primitive{color:#2dbfb8;}.content span.externcrate,.content span.mod,.content a.mod,.block a.current.mod{color:#D2991D;}.content span.trait,.content a.trait,.block a.current.trait{color:#b78cf2;}.content span.traitalias,.content a.traitalias,.block a.current.traitalias{color:#b78cf2;}.content span.fn,.content a.fn,.block a.current.fn,.content span.method,.content a.method,.block a.current.method,.content span.tymethod,.content a.tymethod,.block a.current.tymethod,.content .fnname{color:#2BAB63;}.content span.keyword,.content a.keyword,.block a.current.keyword{color:#D2991D;}.sidebar a{color:#fdbf35;}.sidebar a.current.enum{color:#12ece2;}.sidebar a.current.struct{color:#12ece2;}.sidebar a.current.type{color:#12ece2;}.sidebar a.current.associatedtype{color:#fdbf35;}.sidebar a.current.foreigntype{color:#12ece2;}.sidebar a.current.attr,.sidebar a.current.derive,.sidebar a.current.macro{color:#0be900;}.sidebar a.current.union{color:#12ece2;}.sidebar a.current.constant .sidebar a.current.static{color:#fdbf35;}.sidebar a.current.primitive{color:#12ece2;}.sidebar a.current.externcrate .sidebar a.current.mod{color:#fdbf35;}.sidebar a.current.trait{color:#cca7ff;}.sidebar a.current.traitalias{color:#cca7ff;}.sidebar a.current.fn,.sidebar a.current.method,.sidebar a.current.tymethod{color:#32d479;}.sidebar a.current.keyword{color:#fdbf35;}pre.rust .comment{color:#8d8d8b;}pre.rust .doccomment{color:#8ca375;}nav.main .current{border-top-color:#eee;border-bottom-color:#eee;}nav.main .separator{border-color:#eee;}a{color:#D2991D;}body.source .example-wrap pre.rust a{background:#333;}details.rustdoc-toggle>summary.hideme>span,details.rustdoc-toggle>summary::before{color:#999;}details.rustdoc-toggle>summary::before{filter:invert(100%);}#crate-search,.search-input{color:#111;background-color:#f0f0f0;border-color:#f0f0f0;}#crate-search{border-color:#f0f0f0 !important;}.search-input{border-color:#e0e0e0;}.search-input:focus{border-color:#008dfd;}.stab.empty-impl{background:#FFF5D6;border-color:#FFC600;color:#2f2f2f;}.stab.unstable{background:#FFF5D6;border-color:#FFC600;color:#2f2f2f;}.stab.deprecated{background:#ffc4c4;border-color:#db7b7b;color:#2f2f2f;}.stab.must_implement{background:#F3DFFF;border-color:#b07bdb;color:#2f2f2f;}.stab.portability{background:#F3DFFF;border-color:#b07bdb;color:#2f2f2f;}.stab.portability>code{background:none;}.rightside,.out-of-band{color:grey;}.line-numbers :target{background-color:transparent;}pre.rust .kw{color:#ab8ac1;}pre.rust .kw-2,pre.rust .prelude-ty{color:#769acb;}pre.rust .number,pre.rust .string{color:#83a300;}pre.rust .self,pre.rust .bool-val,pre.rust .prelude-val,pre.rust .attribute,pre.rust .attribute .ident{color:#ee6868;}pre.rust .macro,pre.rust .macro-nonterminal{color:#3E999F;}pre.rust .lifetime{color:#d97f26;}pre.rust .question-mark{color:#ff9011;}.example-wrap>pre.line-number{border-color:#4a4949;}a.test-arrow{color:#dedede;background-color:rgba(78,139,202,0.2);}a.test-arrow:hover{background-color:#4e8bca;}.toggle-label,.code-attribute{color:#999;}:target{background-color:#494a3d;border-right:3px solid #bb7410;}pre.compile_fail{border-left:2px solid rgba(255,0,0,.8);}pre.compile_fail:hover,.information:hover+pre.compile_fail{border-left:2px solid #f00;}pre.should_panic{border-left:2px solid rgba(255,0,0,.8);}pre.should_panic:hover,.information:hover+pre.should_panic{border-left:2px solid #f00;}pre.ignore{border-left:2px solid rgba(255,142,0,.6);}pre.ignore:hover,.information:hover+pre.ignore{border-left:2px solid #ff9200;}.tooltip.compile_fail{color:rgba(255,0,0,.8);}.information>.compile_fail:hover{color:#f00;}.tooltip.should_panic{color:rgba(255,0,0,.8);}.information>.should_panic:hover{color:#f00;}.tooltip.ignore{color:rgba(255,142,0,.6);}.information>.ignore:hover{color:#ff9200;}.search-failed a{color:#0089ff;}.tooltip::after{background-color:#000;color:#fff;border-color:#000;}.tooltip::before{border-color:transparent black transparent transparent;}.notable-traits-tooltiptext{background-color:#111;border-color:#777;}.notable-traits-tooltiptext .notable{border-bottom-color:#d2d2d2;}#titles>button:not(.selected){background-color:#252525;border-top-color:#252525;}#titles>button:hover,#titles>button.selected{border-top-color:#0089ff;background-color:#353535;}#titles>button>div.count{color:#888;}@media (max-width:700px){.sidebar-elems{border-right-color:#000;}}kbd{color:#000;background-color:#fafbfc;border-color:#d1d5da;border-bottom-color:#c6cbd1;box-shadow:inset 0 -1px 0 #c6cbd1;}#settings-menu>a,#help-button>button{border-color:#e0e0e0;background:#f0f0f0;color:#000;}#settings-menu>a:hover,#settings-menu>a:focus,#help-button>button:hover,#help-button>button:focus{border-color:#ffb900;}.popover,.popover::before,#help-button span.top,#help-button span.bottom{border-color:#d2d2d2;}#copy-path{color:#999;}#copy-path>img{filter:invert(50%);}#copy-path:hover>img{filter:invert(65%);}#theme-choices{border-color:#e0e0e0;background-color:#353535;}#theme-choices>button:not(:first-child){border-top-color:#e0e0e0;}#theme-choices>button:hover,#theme-choices>button:focus{background-color:#4e4e4e;}.search-results .result-name span.alias{color:#fff;}.search-results .result-name span.grey{color:#ccc;}#source-sidebar>.title{border-bottom-color:#ccc;}#source-sidebar div.files>a:hover,details.dir-entry summary:hover,#source-sidebar div.files>a:focus,details.dir-entry summary:focus{background-color:#444;}#source-sidebar div.files>a.selected{background-color:#333;}.scraped-example-list .scrape-help{border-color:#aaa;color:#eee;}.scraped-example-list .scrape-help:hover{border-color:white;color:white;}.more-examples-toggle summary,.more-examples-toggle .hide-more{color:#999;}.scraped-example .example-wrap .rust span.highlight{background:rgb(91,59,1);}.scraped-example .example-wrap .rust span.highlight.focus{background:rgb(124,75,15);}.scraped-example:not(.expanded) .code-wrapper:before{background:linear-gradient(to bottom,rgba(53,53,53,1),rgba(53,53,53,0));}.scraped-example:not(.expanded) .code-wrapper:after{background:linear-gradient(to top,rgba(53,53,53,1),rgba(53,53,53,0));}.toggle-line-inner{background:#999;}.toggle-line:hover .toggle-line-inner{background:#c5c5c5;} \ No newline at end of file diff --git a/ch5/down-arrow.svg b/ch5/down-arrow.svg deleted file mode 100644 index 35437e77..00000000 --- a/ch5/down-arrow.svg +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file diff --git a/ch5/help.html b/ch5/help.html new file mode 100644 index 00000000..26794106 --- /dev/null +++ b/ch5/help.html @@ -0,0 +1 @@ +Rustdoc help

Rustdoc help

Back
\ No newline at end of file diff --git a/ch5/implementors/core/clone/trait.Clone.js b/ch5/implementors/core/clone/trait.Clone.js index a6c27053..555f0af1 100644 --- a/ch5/implementors/core/clone/trait.Clone.js +++ b/ch5/implementors/core/clone/trait.Clone.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl Clone for PhysAddr","synthetic":false,"types":["os::mm::address::PhysAddr"]},{"text":"impl Clone for VirtAddr","synthetic":false,"types":["os::mm::address::VirtAddr"]},{"text":"impl Clone for PhysPageNum","synthetic":false,"types":["os::mm::address::PhysPageNum"]},{"text":"impl Clone for VirtPageNum","synthetic":false,"types":["os::mm::address::VirtPageNum"]},{"text":"impl<T: Clone> Clone for SimpleRange<T> where
    T: StepByOne + Copy + PartialEq + PartialOrd + Debug, ","synthetic":false,"types":["os::mm::address::SimpleRange"]},{"text":"impl Clone for MapType","synthetic":false,"types":["os::mm::memory_set::MapType"]},{"text":"impl Clone for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl Clone for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]},{"text":"impl Clone for PageTableEntry","synthetic":false,"types":["os::mm::page_table::PageTableEntry"]},{"text":"impl Clone for TaskStatus","synthetic":false,"types":["os::task::task::TaskStatus"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl Clone for PTEFlags"],["impl<T> Clone for SimpleRange<T>where\n T: StepByOne + Copy + PartialEq + PartialOrd + Debug + Clone,"],["impl Clone for PhysPageNum"],["impl Clone for PhysAddr"],["impl Clone for VirtPageNum"],["impl Clone for PageTableEntry"],["impl Clone for MapPermission"],["impl Clone for MapType"],["impl Clone for VirtAddr"],["impl Clone for TaskStatus"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/cmp/trait.Eq.js b/ch5/implementors/core/cmp/trait.Eq.js index e54db2a2..a8cce6fb 100644 --- a/ch5/implementors/core/cmp/trait.Eq.js +++ b/ch5/implementors/core/cmp/trait.Eq.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl Eq for PhysAddr","synthetic":false,"types":["os::mm::address::PhysAddr"]},{"text":"impl Eq for VirtAddr","synthetic":false,"types":["os::mm::address::VirtAddr"]},{"text":"impl Eq for PhysPageNum","synthetic":false,"types":["os::mm::address::PhysPageNum"]},{"text":"impl Eq for VirtPageNum","synthetic":false,"types":["os::mm::address::VirtPageNum"]},{"text":"impl Eq for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl Eq for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl Eq for VirtAddr"],["impl Eq for PhysPageNum"],["impl Eq for PTEFlags"],["impl Eq for MapPermission"],["impl Eq for PhysAddr"],["impl Eq for VirtPageNum"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/cmp/trait.Ord.js b/ch5/implementors/core/cmp/trait.Ord.js index ee509dd4..5854d356 100644 --- a/ch5/implementors/core/cmp/trait.Ord.js +++ b/ch5/implementors/core/cmp/trait.Ord.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl Ord for PhysAddr","synthetic":false,"types":["os::mm::address::PhysAddr"]},{"text":"impl Ord for VirtAddr","synthetic":false,"types":["os::mm::address::VirtAddr"]},{"text":"impl Ord for PhysPageNum","synthetic":false,"types":["os::mm::address::PhysPageNum"]},{"text":"impl Ord for VirtPageNum","synthetic":false,"types":["os::mm::address::VirtPageNum"]},{"text":"impl Ord for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl Ord for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl Ord for MapPermission"],["impl Ord for PhysAddr"],["impl Ord for PTEFlags"],["impl Ord for VirtPageNum"],["impl Ord for VirtAddr"],["impl Ord for PhysPageNum"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/cmp/trait.PartialEq.js b/ch5/implementors/core/cmp/trait.PartialEq.js index ec6cdba8..3c52ec52 100644 --- a/ch5/implementors/core/cmp/trait.PartialEq.js +++ b/ch5/implementors/core/cmp/trait.PartialEq.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl PartialEq<PhysAddr> for PhysAddr","synthetic":false,"types":["os::mm::address::PhysAddr"]},{"text":"impl PartialEq<VirtAddr> for VirtAddr","synthetic":false,"types":["os::mm::address::VirtAddr"]},{"text":"impl PartialEq<PhysPageNum> for PhysPageNum","synthetic":false,"types":["os::mm::address::PhysPageNum"]},{"text":"impl PartialEq<VirtPageNum> for VirtPageNum","synthetic":false,"types":["os::mm::address::VirtPageNum"]},{"text":"impl PartialEq<MapType> for MapType","synthetic":false,"types":["os::mm::memory_set::MapType"]},{"text":"impl PartialEq<MapPermission> for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl PartialEq<PTEFlags> for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]},{"text":"impl PartialEq<TaskStatus> for TaskStatus","synthetic":false,"types":["os::task::task::TaskStatus"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl PartialEq<VirtAddr> for VirtAddr"],["impl PartialEq<VirtPageNum> for VirtPageNum"],["impl PartialEq<TaskStatus> for TaskStatus"],["impl PartialEq<PhysAddr> for PhysAddr"],["impl PartialEq<PhysPageNum> for PhysPageNum"],["impl PartialEq<PTEFlags> for PTEFlags"],["impl PartialEq<MapType> for MapType"],["impl PartialEq<MapPermission> for MapPermission"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/cmp/trait.PartialOrd.js b/ch5/implementors/core/cmp/trait.PartialOrd.js index 38191d91..55ab5459 100644 --- a/ch5/implementors/core/cmp/trait.PartialOrd.js +++ b/ch5/implementors/core/cmp/trait.PartialOrd.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl PartialOrd<PhysAddr> for PhysAddr","synthetic":false,"types":["os::mm::address::PhysAddr"]},{"text":"impl PartialOrd<VirtAddr> for VirtAddr","synthetic":false,"types":["os::mm::address::VirtAddr"]},{"text":"impl PartialOrd<PhysPageNum> for PhysPageNum","synthetic":false,"types":["os::mm::address::PhysPageNum"]},{"text":"impl PartialOrd<VirtPageNum> for VirtPageNum","synthetic":false,"types":["os::mm::address::VirtPageNum"]},{"text":"impl PartialOrd<MapPermission> for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl PartialOrd<PTEFlags> for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl PartialOrd<VirtPageNum> for VirtPageNum"],["impl PartialOrd<VirtAddr> for VirtAddr"],["impl PartialOrd<MapPermission> for MapPermission"],["impl PartialOrd<PhysPageNum> for PhysPageNum"],["impl PartialOrd<PhysAddr> for PhysAddr"],["impl PartialOrd<PTEFlags> for PTEFlags"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/convert/trait.From.js b/ch5/implementors/core/convert/trait.From.js index d2fbb8c0..40676725 100644 --- a/ch5/implementors/core/convert/trait.From.js +++ b/ch5/implementors/core/convert/trait.From.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl From<usize> for PhysAddr","synthetic":false,"types":["os::mm::address::PhysAddr"]},{"text":"impl From<usize> for PhysPageNum","synthetic":false,"types":["os::mm::address::PhysPageNum"]},{"text":"impl From<usize> for VirtAddr","synthetic":false,"types":["os::mm::address::VirtAddr"]},{"text":"impl From<usize> for VirtPageNum","synthetic":false,"types":["os::mm::address::VirtPageNum"]},{"text":"impl From<PhysAddr> for usize","synthetic":false,"types":[]},{"text":"impl From<PhysPageNum> for usize","synthetic":false,"types":[]},{"text":"impl From<VirtAddr> for usize","synthetic":false,"types":[]},{"text":"impl From<VirtPageNum> for usize","synthetic":false,"types":[]},{"text":"impl From<VirtAddr> for VirtPageNum","synthetic":false,"types":["os::mm::address::VirtPageNum"]},{"text":"impl From<VirtPageNum> for VirtAddr","synthetic":false,"types":["os::mm::address::VirtAddr"]},{"text":"impl From<PhysAddr> for PhysPageNum","synthetic":false,"types":["os::mm::address::PhysPageNum"]},{"text":"impl From<PhysPageNum> for PhysAddr","synthetic":false,"types":["os::mm::address::PhysAddr"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl From<VirtPageNum> for VirtAddr"],["impl From<PhysAddr> for PhysPageNum"],["impl From<PhysAddr> for usize"],["impl From<VirtAddr> for usize"],["impl From<PhysPageNum> for usize"],["impl From<PhysPageNum> for PhysAddr"],["impl From<usize> for VirtPageNum"],["impl From<VirtPageNum> for usize"],["impl From<usize> for VirtAddr"],["impl From<VirtAddr> for VirtPageNum"],["impl From<usize> for PhysAddr"],["impl From<usize> for PhysPageNum"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/fmt/trait.Binary.js b/ch5/implementors/core/fmt/trait.Binary.js index ad893e11..5e6fe660 100644 --- a/ch5/implementors/core/fmt/trait.Binary.js +++ b/ch5/implementors/core/fmt/trait.Binary.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl Binary for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl Binary for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl Binary for PTEFlags"],["impl Binary for MapPermission"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/fmt/trait.Debug.js b/ch5/implementors/core/fmt/trait.Debug.js index d29d3145..06dc2de6 100644 --- a/ch5/implementors/core/fmt/trait.Debug.js +++ b/ch5/implementors/core/fmt/trait.Debug.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl Debug for VirtAddr","synthetic":false,"types":["os::mm::address::VirtAddr"]},{"text":"impl Debug for VirtPageNum","synthetic":false,"types":["os::mm::address::VirtPageNum"]},{"text":"impl Debug for PhysAddr","synthetic":false,"types":["os::mm::address::PhysAddr"]},{"text":"impl Debug for PhysPageNum","synthetic":false,"types":["os::mm::address::PhysPageNum"]},{"text":"impl Debug for FrameTracker","synthetic":false,"types":["os::mm::frame_allocator::FrameTracker"]},{"text":"impl Debug for MapType","synthetic":false,"types":["os::mm::memory_set::MapType"]},{"text":"impl Debug for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl Debug for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl Debug for PhysPageNum"],["impl Debug for VirtAddr"],["impl Debug for PTEFlags"],["impl Debug for MapPermission"],["impl Debug for MapType"],["impl Debug for PhysAddr"],["impl Debug for VirtPageNum"],["impl Debug for FrameTracker"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/fmt/trait.LowerHex.js b/ch5/implementors/core/fmt/trait.LowerHex.js index eec0f7cb..04ef597e 100644 --- a/ch5/implementors/core/fmt/trait.LowerHex.js +++ b/ch5/implementors/core/fmt/trait.LowerHex.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl LowerHex for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl LowerHex for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl LowerHex for MapPermission"],["impl LowerHex for PTEFlags"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/fmt/trait.Octal.js b/ch5/implementors/core/fmt/trait.Octal.js index 0a023864..ddba3707 100644 --- a/ch5/implementors/core/fmt/trait.Octal.js +++ b/ch5/implementors/core/fmt/trait.Octal.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl Octal for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl Octal for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl Octal for MapPermission"],["impl Octal for PTEFlags"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/fmt/trait.UpperHex.js b/ch5/implementors/core/fmt/trait.UpperHex.js index 0e55c8ef..38891636 100644 --- a/ch5/implementors/core/fmt/trait.UpperHex.js +++ b/ch5/implementors/core/fmt/trait.UpperHex.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl UpperHex for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl UpperHex for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl UpperHex for MapPermission"],["impl UpperHex for PTEFlags"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/fmt/trait.Write.js b/ch5/implementors/core/fmt/trait.Write.js index 0d40b97a..d9d7c42d 100644 --- a/ch5/implementors/core/fmt/trait.Write.js +++ b/ch5/implementors/core/fmt/trait.Write.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl Write for Stdout","synthetic":false,"types":["os::console::Stdout"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl Write for Stdout"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/hash/trait.Hash.js b/ch5/implementors/core/hash/trait.Hash.js index f8f1bed7..421febf0 100644 --- a/ch5/implementors/core/hash/trait.Hash.js +++ b/ch5/implementors/core/hash/trait.Hash.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl Hash for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl Hash for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl Hash for MapPermission"],["impl Hash for PTEFlags"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/iter/traits/collect/trait.Extend.js b/ch5/implementors/core/iter/traits/collect/trait.Extend.js index 8f3dc77c..2e9493cb 100644 --- a/ch5/implementors/core/iter/traits/collect/trait.Extend.js +++ b/ch5/implementors/core/iter/traits/collect/trait.Extend.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl Extend<MapPermission> for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl Extend<PTEFlags> for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl Extend<PTEFlags> for PTEFlags"],["impl Extend<MapPermission> for MapPermission"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/iter/traits/collect/trait.FromIterator.js b/ch5/implementors/core/iter/traits/collect/trait.FromIterator.js index 18bb59c7..7c30dada 100644 --- a/ch5/implementors/core/iter/traits/collect/trait.FromIterator.js +++ b/ch5/implementors/core/iter/traits/collect/trait.FromIterator.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl FromIterator<MapPermission> for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl FromIterator<PTEFlags> for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl FromIterator<PTEFlags> for PTEFlags"],["impl FromIterator<MapPermission> for MapPermission"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/iter/traits/collect/trait.IntoIterator.js b/ch5/implementors/core/iter/traits/collect/trait.IntoIterator.js index d4d1dc9e..a6b687ec 100644 --- a/ch5/implementors/core/iter/traits/collect/trait.IntoIterator.js +++ b/ch5/implementors/core/iter/traits/collect/trait.IntoIterator.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl<T> IntoIterator for SimpleRange<T> where
    T: StepByOne + Copy + PartialEq + PartialOrd + Debug, ","synthetic":false,"types":["os::mm::address::SimpleRange"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl<T> IntoIterator for SimpleRange<T>where\n T: StepByOne + Copy + PartialEq + PartialOrd + Debug,"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/iter/traits/iterator/trait.Iterator.js b/ch5/implementors/core/iter/traits/iterator/trait.Iterator.js index d9226361..841f8ca8 100644 --- a/ch5/implementors/core/iter/traits/iterator/trait.Iterator.js +++ b/ch5/implementors/core/iter/traits/iterator/trait.Iterator.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl<T> Iterator for SimpleRangeIterator<T> where
    T: StepByOne + Copy + PartialEq + PartialOrd + Debug, ","synthetic":false,"types":["os::mm::address::SimpleRangeIterator"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl<T> Iterator for SimpleRangeIterator<T>where\n T: StepByOne + Copy + PartialEq + PartialOrd + Debug,"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/marker/trait.Copy.js b/ch5/implementors/core/marker/trait.Copy.js index 250f562d..e0030fc6 100644 --- a/ch5/implementors/core/marker/trait.Copy.js +++ b/ch5/implementors/core/marker/trait.Copy.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl Copy for PhysAddr","synthetic":false,"types":["os::mm::address::PhysAddr"]},{"text":"impl Copy for VirtAddr","synthetic":false,"types":["os::mm::address::VirtAddr"]},{"text":"impl Copy for PhysPageNum","synthetic":false,"types":["os::mm::address::PhysPageNum"]},{"text":"impl Copy for VirtPageNum","synthetic":false,"types":["os::mm::address::VirtPageNum"]},{"text":"impl<T: Copy> Copy for SimpleRange<T> where
    T: StepByOne + Copy + PartialEq + PartialOrd + Debug, ","synthetic":false,"types":["os::mm::address::SimpleRange"]},{"text":"impl Copy for MapType","synthetic":false,"types":["os::mm::memory_set::MapType"]},{"text":"impl Copy for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl Copy for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]},{"text":"impl Copy for PageTableEntry","synthetic":false,"types":["os::mm::page_table::PageTableEntry"]},{"text":"impl Copy for TaskStatus","synthetic":false,"types":["os::task::task::TaskStatus"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl Copy for VirtAddr"],["impl Copy for PhysAddr"],["impl Copy for MapPermission"],["impl<T> Copy for SimpleRange<T>where\n T: StepByOne + Copy + PartialEq + PartialOrd + Debug + Copy,"],["impl Copy for PageTableEntry"],["impl Copy for TaskStatus"],["impl Copy for MapType"],["impl Copy for VirtPageNum"],["impl Copy for PhysPageNum"],["impl Copy for PTEFlags"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/marker/trait.Freeze.js b/ch5/implementors/core/marker/trait.Freeze.js index ba254ad1..46ac8e9e 100644 --- a/ch5/implementors/core/marker/trait.Freeze.js +++ b/ch5/implementors/core/marker/trait.Freeze.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl Freeze for Stdout","synthetic":true,"types":["os::console::Stdout"]},{"text":"impl Freeze for APP_NAMES","synthetic":true,"types":["os::loader::APP_NAMES"]},{"text":"impl Freeze for PhysAddr","synthetic":true,"types":["os::mm::address::PhysAddr"]},{"text":"impl Freeze for VirtAddr","synthetic":true,"types":["os::mm::address::VirtAddr"]},{"text":"impl Freeze for PhysPageNum","synthetic":true,"types":["os::mm::address::PhysPageNum"]},{"text":"impl Freeze for VirtPageNum","synthetic":true,"types":["os::mm::address::VirtPageNum"]},{"text":"impl<T> Freeze for SimpleRange<T> where
    T: Freeze, ","synthetic":true,"types":["os::mm::address::SimpleRange"]},{"text":"impl<T> Freeze for SimpleRangeIterator<T> where
    T: Freeze, ","synthetic":true,"types":["os::mm::address::SimpleRangeIterator"]},{"text":"impl Freeze for FrameTracker","synthetic":true,"types":["os::mm::frame_allocator::FrameTracker"]},{"text":"impl Freeze for StackFrameAllocator","synthetic":true,"types":["os::mm::frame_allocator::StackFrameAllocator"]},{"text":"impl Freeze for FRAME_ALLOCATOR","synthetic":true,"types":["os::mm::frame_allocator::FRAME_ALLOCATOR"]},{"text":"impl Freeze for KERNEL_SPACE","synthetic":true,"types":["os::mm::memory_set::KERNEL_SPACE"]},{"text":"impl Freeze for MemorySet","synthetic":true,"types":["os::mm::memory_set::MemorySet"]},{"text":"impl Freeze for MapArea","synthetic":true,"types":["os::mm::memory_set::MapArea"]},{"text":"impl Freeze for MapType","synthetic":true,"types":["os::mm::memory_set::MapType"]},{"text":"impl Freeze for MapPermission","synthetic":true,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl Freeze for PTEFlags","synthetic":true,"types":["os::mm::page_table::PTEFlags"]},{"text":"impl Freeze for PageTableEntry","synthetic":true,"types":["os::mm::page_table::PageTableEntry"]},{"text":"impl Freeze for PageTable","synthetic":true,"types":["os::mm::page_table::PageTable"]},{"text":"impl<T> !Freeze for UPSafeCell<T>","synthetic":true,"types":["os::sync::up::UPSafeCell"]},{"text":"impl Freeze for TaskContext","synthetic":true,"types":["os::task::context::TaskContext"]},{"text":"impl Freeze for TaskManager","synthetic":true,"types":["os::task::manager::TaskManager"]},{"text":"impl Freeze for TASK_MANAGER","synthetic":true,"types":["os::task::manager::TASK_MANAGER"]},{"text":"impl Freeze for PidAllocator","synthetic":true,"types":["os::task::pid::PidAllocator"]},{"text":"impl Freeze for PID_ALLOCATOR","synthetic":true,"types":["os::task::pid::PID_ALLOCATOR"]},{"text":"impl Freeze for PidHandle","synthetic":true,"types":["os::task::pid::PidHandle"]},{"text":"impl Freeze for KernelStack","synthetic":true,"types":["os::task::pid::KernelStack"]},{"text":"impl Freeze for Processor","synthetic":true,"types":["os::task::processor::Processor"]},{"text":"impl Freeze for PROCESSOR","synthetic":true,"types":["os::task::processor::PROCESSOR"]},{"text":"impl !Freeze for TaskControlBlock","synthetic":true,"types":["os::task::task::TaskControlBlock"]},{"text":"impl Freeze for TaskControlBlockInner","synthetic":true,"types":["os::task::task::TaskControlBlockInner"]},{"text":"impl Freeze for TaskStatus","synthetic":true,"types":["os::task::task::TaskStatus"]},{"text":"impl Freeze for INITPROC","synthetic":true,"types":["os::task::INITPROC"]},{"text":"impl Freeze for TrapContext","synthetic":true,"types":["os::trap::context::TrapContext"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl Freeze for Stdout",1,["os::console::Stdout"]],["impl Freeze for APP_NAMES",1,["os::loader::APP_NAMES"]],["impl Freeze for PhysAddr",1,["os::mm::address::PhysAddr"]],["impl Freeze for VirtAddr",1,["os::mm::address::VirtAddr"]],["impl Freeze for PhysPageNum",1,["os::mm::address::PhysPageNum"]],["impl Freeze for VirtPageNum",1,["os::mm::address::VirtPageNum"]],["impl<T> Freeze for SimpleRange<T>where\n T: Freeze,",1,["os::mm::address::SimpleRange"]],["impl<T> Freeze for SimpleRangeIterator<T>where\n T: Freeze,",1,["os::mm::address::SimpleRangeIterator"]],["impl Freeze for FrameTracker",1,["os::mm::frame_allocator::FrameTracker"]],["impl Freeze for StackFrameAllocator",1,["os::mm::frame_allocator::StackFrameAllocator"]],["impl Freeze for FRAME_ALLOCATOR",1,["os::mm::frame_allocator::FRAME_ALLOCATOR"]],["impl Freeze for KERNEL_SPACE",1,["os::mm::memory_set::KERNEL_SPACE"]],["impl Freeze for MemorySet",1,["os::mm::memory_set::MemorySet"]],["impl Freeze for MapArea",1,["os::mm::memory_set::MapArea"]],["impl Freeze for MapType",1,["os::mm::memory_set::MapType"]],["impl Freeze for MapPermission",1,["os::mm::memory_set::MapPermission"]],["impl Freeze for PTEFlags",1,["os::mm::page_table::PTEFlags"]],["impl Freeze for PageTableEntry",1,["os::mm::page_table::PageTableEntry"]],["impl Freeze for PageTable",1,["os::mm::page_table::PageTable"]],["impl<T> !Freeze for UPSafeCell<T>",1,["os::sync::up::UPSafeCell"]],["impl Freeze for TaskContext",1,["os::task::context::TaskContext"]],["impl Freeze for TaskManager",1,["os::task::manager::TaskManager"]],["impl Freeze for TASK_MANAGER",1,["os::task::manager::TASK_MANAGER"]],["impl Freeze for PidAllocator",1,["os::task::pid::PidAllocator"]],["impl Freeze for PID_ALLOCATOR",1,["os::task::pid::PID_ALLOCATOR"]],["impl Freeze for PidHandle",1,["os::task::pid::PidHandle"]],["impl Freeze for KernelStack",1,["os::task::pid::KernelStack"]],["impl Freeze for Processor",1,["os::task::processor::Processor"]],["impl Freeze for PROCESSOR",1,["os::task::processor::PROCESSOR"]],["impl !Freeze for TaskControlBlock",1,["os::task::task::TaskControlBlock"]],["impl Freeze for TaskControlBlockInner",1,["os::task::task::TaskControlBlockInner"]],["impl Freeze for TaskStatus",1,["os::task::task::TaskStatus"]],["impl Freeze for INITPROC",1,["os::task::INITPROC"]],["impl Freeze for TrapContext",1,["os::trap::context::TrapContext"]]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/marker/trait.Send.js b/ch5/implementors/core/marker/trait.Send.js index bf066f2f..5543af9b 100644 --- a/ch5/implementors/core/marker/trait.Send.js +++ b/ch5/implementors/core/marker/trait.Send.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl Send for Stdout","synthetic":true,"types":["os::console::Stdout"]},{"text":"impl Send for APP_NAMES","synthetic":true,"types":["os::loader::APP_NAMES"]},{"text":"impl Send for PhysAddr","synthetic":true,"types":["os::mm::address::PhysAddr"]},{"text":"impl Send for VirtAddr","synthetic":true,"types":["os::mm::address::VirtAddr"]},{"text":"impl Send for PhysPageNum","synthetic":true,"types":["os::mm::address::PhysPageNum"]},{"text":"impl Send for VirtPageNum","synthetic":true,"types":["os::mm::address::VirtPageNum"]},{"text":"impl<T> Send for SimpleRange<T> where
    T: Send, ","synthetic":true,"types":["os::mm::address::SimpleRange"]},{"text":"impl<T> Send for SimpleRangeIterator<T> where
    T: Send, ","synthetic":true,"types":["os::mm::address::SimpleRangeIterator"]},{"text":"impl Send for FrameTracker","synthetic":true,"types":["os::mm::frame_allocator::FrameTracker"]},{"text":"impl Send for StackFrameAllocator","synthetic":true,"types":["os::mm::frame_allocator::StackFrameAllocator"]},{"text":"impl Send for FRAME_ALLOCATOR","synthetic":true,"types":["os::mm::frame_allocator::FRAME_ALLOCATOR"]},{"text":"impl Send for KERNEL_SPACE","synthetic":true,"types":["os::mm::memory_set::KERNEL_SPACE"]},{"text":"impl Send for MemorySet","synthetic":true,"types":["os::mm::memory_set::MemorySet"]},{"text":"impl Send for MapArea","synthetic":true,"types":["os::mm::memory_set::MapArea"]},{"text":"impl Send for MapType","synthetic":true,"types":["os::mm::memory_set::MapType"]},{"text":"impl Send for MapPermission","synthetic":true,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl Send for PTEFlags","synthetic":true,"types":["os::mm::page_table::PTEFlags"]},{"text":"impl Send for PageTableEntry","synthetic":true,"types":["os::mm::page_table::PageTableEntry"]},{"text":"impl Send for PageTable","synthetic":true,"types":["os::mm::page_table::PageTable"]},{"text":"impl<T> Send for UPSafeCell<T> where
    T: Send, ","synthetic":true,"types":["os::sync::up::UPSafeCell"]},{"text":"impl Send for TaskContext","synthetic":true,"types":["os::task::context::TaskContext"]},{"text":"impl Send for TaskManager","synthetic":true,"types":["os::task::manager::TaskManager"]},{"text":"impl Send for TASK_MANAGER","synthetic":true,"types":["os::task::manager::TASK_MANAGER"]},{"text":"impl Send for PidAllocator","synthetic":true,"types":["os::task::pid::PidAllocator"]},{"text":"impl Send for PID_ALLOCATOR","synthetic":true,"types":["os::task::pid::PID_ALLOCATOR"]},{"text":"impl Send for PidHandle","synthetic":true,"types":["os::task::pid::PidHandle"]},{"text":"impl Send for KernelStack","synthetic":true,"types":["os::task::pid::KernelStack"]},{"text":"impl Send for Processor","synthetic":true,"types":["os::task::processor::Processor"]},{"text":"impl Send for PROCESSOR","synthetic":true,"types":["os::task::processor::PROCESSOR"]},{"text":"impl Send for TaskControlBlock","synthetic":true,"types":["os::task::task::TaskControlBlock"]},{"text":"impl Send for TaskControlBlockInner","synthetic":true,"types":["os::task::task::TaskControlBlockInner"]},{"text":"impl Send for TaskStatus","synthetic":true,"types":["os::task::task::TaskStatus"]},{"text":"impl Send for INITPROC","synthetic":true,"types":["os::task::INITPROC"]},{"text":"impl Send for TrapContext","synthetic":true,"types":["os::trap::context::TrapContext"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl Send for Stdout",1,["os::console::Stdout"]],["impl Send for APP_NAMES",1,["os::loader::APP_NAMES"]],["impl Send for PhysAddr",1,["os::mm::address::PhysAddr"]],["impl Send for VirtAddr",1,["os::mm::address::VirtAddr"]],["impl Send for PhysPageNum",1,["os::mm::address::PhysPageNum"]],["impl Send for VirtPageNum",1,["os::mm::address::VirtPageNum"]],["impl<T> Send for SimpleRange<T>where\n T: Send,",1,["os::mm::address::SimpleRange"]],["impl<T> Send for SimpleRangeIterator<T>where\n T: Send,",1,["os::mm::address::SimpleRangeIterator"]],["impl Send for FrameTracker",1,["os::mm::frame_allocator::FrameTracker"]],["impl Send for StackFrameAllocator",1,["os::mm::frame_allocator::StackFrameAllocator"]],["impl Send for FRAME_ALLOCATOR",1,["os::mm::frame_allocator::FRAME_ALLOCATOR"]],["impl Send for KERNEL_SPACE",1,["os::mm::memory_set::KERNEL_SPACE"]],["impl Send for MemorySet",1,["os::mm::memory_set::MemorySet"]],["impl Send for MapArea",1,["os::mm::memory_set::MapArea"]],["impl Send for MapType",1,["os::mm::memory_set::MapType"]],["impl Send for MapPermission",1,["os::mm::memory_set::MapPermission"]],["impl Send for PTEFlags",1,["os::mm::page_table::PTEFlags"]],["impl Send for PageTableEntry",1,["os::mm::page_table::PageTableEntry"]],["impl Send for PageTable",1,["os::mm::page_table::PageTable"]],["impl<T> Send for UPSafeCell<T>where\n T: Send,",1,["os::sync::up::UPSafeCell"]],["impl Send for TaskContext",1,["os::task::context::TaskContext"]],["impl Send for TaskManager",1,["os::task::manager::TaskManager"]],["impl Send for TASK_MANAGER",1,["os::task::manager::TASK_MANAGER"]],["impl Send for PidAllocator",1,["os::task::pid::PidAllocator"]],["impl Send for PID_ALLOCATOR",1,["os::task::pid::PID_ALLOCATOR"]],["impl Send for PidHandle",1,["os::task::pid::PidHandle"]],["impl Send for KernelStack",1,["os::task::pid::KernelStack"]],["impl Send for Processor",1,["os::task::processor::Processor"]],["impl Send for PROCESSOR",1,["os::task::processor::PROCESSOR"]],["impl Send for TaskControlBlock",1,["os::task::task::TaskControlBlock"]],["impl Send for TaskControlBlockInner",1,["os::task::task::TaskControlBlockInner"]],["impl Send for TaskStatus",1,["os::task::task::TaskStatus"]],["impl Send for INITPROC",1,["os::task::INITPROC"]],["impl Send for TrapContext",1,["os::trap::context::TrapContext"]]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/marker/trait.StructuralEq.js b/ch5/implementors/core/marker/trait.StructuralEq.js index a8001b08..2c422c02 100644 --- a/ch5/implementors/core/marker/trait.StructuralEq.js +++ b/ch5/implementors/core/marker/trait.StructuralEq.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl StructuralEq for PhysAddr","synthetic":false,"types":["os::mm::address::PhysAddr"]},{"text":"impl StructuralEq for VirtAddr","synthetic":false,"types":["os::mm::address::VirtAddr"]},{"text":"impl StructuralEq for PhysPageNum","synthetic":false,"types":["os::mm::address::PhysPageNum"]},{"text":"impl StructuralEq for VirtPageNum","synthetic":false,"types":["os::mm::address::VirtPageNum"]},{"text":"impl StructuralEq for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl StructuralEq for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl StructuralEq for PhysAddr"],["impl StructuralEq for PhysPageNum"],["impl StructuralEq for PTEFlags"],["impl StructuralEq for VirtPageNum"],["impl StructuralEq for VirtAddr"],["impl StructuralEq for MapPermission"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/marker/trait.StructuralPartialEq.js b/ch5/implementors/core/marker/trait.StructuralPartialEq.js index 71226479..96ec790a 100644 --- a/ch5/implementors/core/marker/trait.StructuralPartialEq.js +++ b/ch5/implementors/core/marker/trait.StructuralPartialEq.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl StructuralPartialEq for PhysAddr","synthetic":false,"types":["os::mm::address::PhysAddr"]},{"text":"impl StructuralPartialEq for VirtAddr","synthetic":false,"types":["os::mm::address::VirtAddr"]},{"text":"impl StructuralPartialEq for PhysPageNum","synthetic":false,"types":["os::mm::address::PhysPageNum"]},{"text":"impl StructuralPartialEq for VirtPageNum","synthetic":false,"types":["os::mm::address::VirtPageNum"]},{"text":"impl StructuralPartialEq for MapType","synthetic":false,"types":["os::mm::memory_set::MapType"]},{"text":"impl StructuralPartialEq for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl StructuralPartialEq for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]},{"text":"impl StructuralPartialEq for TaskStatus","synthetic":false,"types":["os::task::task::TaskStatus"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl StructuralPartialEq for PhysAddr"],["impl StructuralPartialEq for VirtPageNum"],["impl StructuralPartialEq for PTEFlags"],["impl StructuralPartialEq for MapType"],["impl StructuralPartialEq for VirtAddr"],["impl StructuralPartialEq for MapPermission"],["impl StructuralPartialEq for TaskStatus"],["impl StructuralPartialEq for PhysPageNum"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/marker/trait.Sync.js b/ch5/implementors/core/marker/trait.Sync.js index d942059f..2d020b0a 100644 --- a/ch5/implementors/core/marker/trait.Sync.js +++ b/ch5/implementors/core/marker/trait.Sync.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl Sync for Stdout","synthetic":true,"types":["os::console::Stdout"]},{"text":"impl Sync for APP_NAMES","synthetic":true,"types":["os::loader::APP_NAMES"]},{"text":"impl Sync for PhysAddr","synthetic":true,"types":["os::mm::address::PhysAddr"]},{"text":"impl Sync for VirtAddr","synthetic":true,"types":["os::mm::address::VirtAddr"]},{"text":"impl Sync for PhysPageNum","synthetic":true,"types":["os::mm::address::PhysPageNum"]},{"text":"impl Sync for VirtPageNum","synthetic":true,"types":["os::mm::address::VirtPageNum"]},{"text":"impl<T> Sync for SimpleRange<T> where
    T: Sync, ","synthetic":true,"types":["os::mm::address::SimpleRange"]},{"text":"impl<T> Sync for SimpleRangeIterator<T> where
    T: Sync, ","synthetic":true,"types":["os::mm::address::SimpleRangeIterator"]},{"text":"impl Sync for FrameTracker","synthetic":true,"types":["os::mm::frame_allocator::FrameTracker"]},{"text":"impl Sync for StackFrameAllocator","synthetic":true,"types":["os::mm::frame_allocator::StackFrameAllocator"]},{"text":"impl Sync for FRAME_ALLOCATOR","synthetic":true,"types":["os::mm::frame_allocator::FRAME_ALLOCATOR"]},{"text":"impl Sync for KERNEL_SPACE","synthetic":true,"types":["os::mm::memory_set::KERNEL_SPACE"]},{"text":"impl Sync for MemorySet","synthetic":true,"types":["os::mm::memory_set::MemorySet"]},{"text":"impl Sync for MapArea","synthetic":true,"types":["os::mm::memory_set::MapArea"]},{"text":"impl Sync for MapType","synthetic":true,"types":["os::mm::memory_set::MapType"]},{"text":"impl Sync for MapPermission","synthetic":true,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl Sync for PTEFlags","synthetic":true,"types":["os::mm::page_table::PTEFlags"]},{"text":"impl Sync for PageTableEntry","synthetic":true,"types":["os::mm::page_table::PageTableEntry"]},{"text":"impl Sync for PageTable","synthetic":true,"types":["os::mm::page_table::PageTable"]},{"text":"impl Sync for TaskContext","synthetic":true,"types":["os::task::context::TaskContext"]},{"text":"impl Sync for TaskManager","synthetic":true,"types":["os::task::manager::TaskManager"]},{"text":"impl Sync for TASK_MANAGER","synthetic":true,"types":["os::task::manager::TASK_MANAGER"]},{"text":"impl Sync for PidAllocator","synthetic":true,"types":["os::task::pid::PidAllocator"]},{"text":"impl Sync for PID_ALLOCATOR","synthetic":true,"types":["os::task::pid::PID_ALLOCATOR"]},{"text":"impl Sync for PidHandle","synthetic":true,"types":["os::task::pid::PidHandle"]},{"text":"impl Sync for KernelStack","synthetic":true,"types":["os::task::pid::KernelStack"]},{"text":"impl Sync for Processor","synthetic":true,"types":["os::task::processor::Processor"]},{"text":"impl Sync for PROCESSOR","synthetic":true,"types":["os::task::processor::PROCESSOR"]},{"text":"impl Sync for TaskControlBlock","synthetic":true,"types":["os::task::task::TaskControlBlock"]},{"text":"impl Sync for TaskControlBlockInner","synthetic":true,"types":["os::task::task::TaskControlBlockInner"]},{"text":"impl Sync for TaskStatus","synthetic":true,"types":["os::task::task::TaskStatus"]},{"text":"impl Sync for INITPROC","synthetic":true,"types":["os::task::INITPROC"]},{"text":"impl Sync for TrapContext","synthetic":true,"types":["os::trap::context::TrapContext"]},{"text":"impl<T> Sync for UPSafeCell<T>","synthetic":false,"types":["os::sync::up::UPSafeCell"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl Sync for Stdout",1,["os::console::Stdout"]],["impl Sync for APP_NAMES",1,["os::loader::APP_NAMES"]],["impl Sync for PhysAddr",1,["os::mm::address::PhysAddr"]],["impl Sync for VirtAddr",1,["os::mm::address::VirtAddr"]],["impl Sync for PhysPageNum",1,["os::mm::address::PhysPageNum"]],["impl Sync for VirtPageNum",1,["os::mm::address::VirtPageNum"]],["impl<T> Sync for SimpleRange<T>where\n T: Sync,",1,["os::mm::address::SimpleRange"]],["impl<T> Sync for SimpleRangeIterator<T>where\n T: Sync,",1,["os::mm::address::SimpleRangeIterator"]],["impl Sync for FrameTracker",1,["os::mm::frame_allocator::FrameTracker"]],["impl Sync for StackFrameAllocator",1,["os::mm::frame_allocator::StackFrameAllocator"]],["impl Sync for FRAME_ALLOCATOR",1,["os::mm::frame_allocator::FRAME_ALLOCATOR"]],["impl Sync for KERNEL_SPACE",1,["os::mm::memory_set::KERNEL_SPACE"]],["impl Sync for MemorySet",1,["os::mm::memory_set::MemorySet"]],["impl Sync for MapArea",1,["os::mm::memory_set::MapArea"]],["impl Sync for MapType",1,["os::mm::memory_set::MapType"]],["impl Sync for MapPermission",1,["os::mm::memory_set::MapPermission"]],["impl Sync for PTEFlags",1,["os::mm::page_table::PTEFlags"]],["impl Sync for PageTableEntry",1,["os::mm::page_table::PageTableEntry"]],["impl Sync for PageTable",1,["os::mm::page_table::PageTable"]],["impl Sync for TaskContext",1,["os::task::context::TaskContext"]],["impl Sync for TaskManager",1,["os::task::manager::TaskManager"]],["impl Sync for TASK_MANAGER",1,["os::task::manager::TASK_MANAGER"]],["impl Sync for PidAllocator",1,["os::task::pid::PidAllocator"]],["impl Sync for PID_ALLOCATOR",1,["os::task::pid::PID_ALLOCATOR"]],["impl Sync for PidHandle",1,["os::task::pid::PidHandle"]],["impl Sync for KernelStack",1,["os::task::pid::KernelStack"]],["impl Sync for Processor",1,["os::task::processor::Processor"]],["impl Sync for PROCESSOR",1,["os::task::processor::PROCESSOR"]],["impl Sync for TaskControlBlock",1,["os::task::task::TaskControlBlock"]],["impl Sync for TaskControlBlockInner",1,["os::task::task::TaskControlBlockInner"]],["impl Sync for TaskStatus",1,["os::task::task::TaskStatus"]],["impl Sync for INITPROC",1,["os::task::INITPROC"]],["impl Sync for TrapContext",1,["os::trap::context::TrapContext"]],["impl<T> Sync for UPSafeCell<T>"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/marker/trait.Unpin.js b/ch5/implementors/core/marker/trait.Unpin.js index b923f08f..9a691b6a 100644 --- a/ch5/implementors/core/marker/trait.Unpin.js +++ b/ch5/implementors/core/marker/trait.Unpin.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl Unpin for Stdout","synthetic":true,"types":["os::console::Stdout"]},{"text":"impl Unpin for APP_NAMES","synthetic":true,"types":["os::loader::APP_NAMES"]},{"text":"impl Unpin for PhysAddr","synthetic":true,"types":["os::mm::address::PhysAddr"]},{"text":"impl Unpin for VirtAddr","synthetic":true,"types":["os::mm::address::VirtAddr"]},{"text":"impl Unpin for PhysPageNum","synthetic":true,"types":["os::mm::address::PhysPageNum"]},{"text":"impl Unpin for VirtPageNum","synthetic":true,"types":["os::mm::address::VirtPageNum"]},{"text":"impl<T> Unpin for SimpleRange<T> where
    T: Unpin, ","synthetic":true,"types":["os::mm::address::SimpleRange"]},{"text":"impl<T> Unpin for SimpleRangeIterator<T> where
    T: Unpin, ","synthetic":true,"types":["os::mm::address::SimpleRangeIterator"]},{"text":"impl Unpin for FrameTracker","synthetic":true,"types":["os::mm::frame_allocator::FrameTracker"]},{"text":"impl Unpin for StackFrameAllocator","synthetic":true,"types":["os::mm::frame_allocator::StackFrameAllocator"]},{"text":"impl Unpin for FRAME_ALLOCATOR","synthetic":true,"types":["os::mm::frame_allocator::FRAME_ALLOCATOR"]},{"text":"impl Unpin for KERNEL_SPACE","synthetic":true,"types":["os::mm::memory_set::KERNEL_SPACE"]},{"text":"impl Unpin for MemorySet","synthetic":true,"types":["os::mm::memory_set::MemorySet"]},{"text":"impl Unpin for MapArea","synthetic":true,"types":["os::mm::memory_set::MapArea"]},{"text":"impl Unpin for MapType","synthetic":true,"types":["os::mm::memory_set::MapType"]},{"text":"impl Unpin for MapPermission","synthetic":true,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl Unpin for PTEFlags","synthetic":true,"types":["os::mm::page_table::PTEFlags"]},{"text":"impl Unpin for PageTableEntry","synthetic":true,"types":["os::mm::page_table::PageTableEntry"]},{"text":"impl Unpin for PageTable","synthetic":true,"types":["os::mm::page_table::PageTable"]},{"text":"impl<T> Unpin for UPSafeCell<T> where
    T: Unpin, ","synthetic":true,"types":["os::sync::up::UPSafeCell"]},{"text":"impl Unpin for TaskContext","synthetic":true,"types":["os::task::context::TaskContext"]},{"text":"impl Unpin for TaskManager","synthetic":true,"types":["os::task::manager::TaskManager"]},{"text":"impl Unpin for TASK_MANAGER","synthetic":true,"types":["os::task::manager::TASK_MANAGER"]},{"text":"impl Unpin for PidAllocator","synthetic":true,"types":["os::task::pid::PidAllocator"]},{"text":"impl Unpin for PID_ALLOCATOR","synthetic":true,"types":["os::task::pid::PID_ALLOCATOR"]},{"text":"impl Unpin for PidHandle","synthetic":true,"types":["os::task::pid::PidHandle"]},{"text":"impl Unpin for KernelStack","synthetic":true,"types":["os::task::pid::KernelStack"]},{"text":"impl Unpin for Processor","synthetic":true,"types":["os::task::processor::Processor"]},{"text":"impl Unpin for PROCESSOR","synthetic":true,"types":["os::task::processor::PROCESSOR"]},{"text":"impl Unpin for TaskControlBlock","synthetic":true,"types":["os::task::task::TaskControlBlock"]},{"text":"impl Unpin for TaskControlBlockInner","synthetic":true,"types":["os::task::task::TaskControlBlockInner"]},{"text":"impl Unpin for TaskStatus","synthetic":true,"types":["os::task::task::TaskStatus"]},{"text":"impl Unpin for INITPROC","synthetic":true,"types":["os::task::INITPROC"]},{"text":"impl Unpin for TrapContext","synthetic":true,"types":["os::trap::context::TrapContext"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl Unpin for Stdout",1,["os::console::Stdout"]],["impl Unpin for APP_NAMES",1,["os::loader::APP_NAMES"]],["impl Unpin for PhysAddr",1,["os::mm::address::PhysAddr"]],["impl Unpin for VirtAddr",1,["os::mm::address::VirtAddr"]],["impl Unpin for PhysPageNum",1,["os::mm::address::PhysPageNum"]],["impl Unpin for VirtPageNum",1,["os::mm::address::VirtPageNum"]],["impl<T> Unpin for SimpleRange<T>where\n T: Unpin,",1,["os::mm::address::SimpleRange"]],["impl<T> Unpin for SimpleRangeIterator<T>where\n T: Unpin,",1,["os::mm::address::SimpleRangeIterator"]],["impl Unpin for FrameTracker",1,["os::mm::frame_allocator::FrameTracker"]],["impl Unpin for StackFrameAllocator",1,["os::mm::frame_allocator::StackFrameAllocator"]],["impl Unpin for FRAME_ALLOCATOR",1,["os::mm::frame_allocator::FRAME_ALLOCATOR"]],["impl Unpin for KERNEL_SPACE",1,["os::mm::memory_set::KERNEL_SPACE"]],["impl Unpin for MemorySet",1,["os::mm::memory_set::MemorySet"]],["impl Unpin for MapArea",1,["os::mm::memory_set::MapArea"]],["impl Unpin for MapType",1,["os::mm::memory_set::MapType"]],["impl Unpin for MapPermission",1,["os::mm::memory_set::MapPermission"]],["impl Unpin for PTEFlags",1,["os::mm::page_table::PTEFlags"]],["impl Unpin for PageTableEntry",1,["os::mm::page_table::PageTableEntry"]],["impl Unpin for PageTable",1,["os::mm::page_table::PageTable"]],["impl<T> Unpin for UPSafeCell<T>where\n T: Unpin,",1,["os::sync::up::UPSafeCell"]],["impl Unpin for TaskContext",1,["os::task::context::TaskContext"]],["impl Unpin for TaskManager",1,["os::task::manager::TaskManager"]],["impl Unpin for TASK_MANAGER",1,["os::task::manager::TASK_MANAGER"]],["impl Unpin for PidAllocator",1,["os::task::pid::PidAllocator"]],["impl Unpin for PID_ALLOCATOR",1,["os::task::pid::PID_ALLOCATOR"]],["impl Unpin for PidHandle",1,["os::task::pid::PidHandle"]],["impl Unpin for KernelStack",1,["os::task::pid::KernelStack"]],["impl Unpin for Processor",1,["os::task::processor::Processor"]],["impl Unpin for PROCESSOR",1,["os::task::processor::PROCESSOR"]],["impl Unpin for TaskControlBlock",1,["os::task::task::TaskControlBlock"]],["impl Unpin for TaskControlBlockInner",1,["os::task::task::TaskControlBlockInner"]],["impl Unpin for TaskStatus",1,["os::task::task::TaskStatus"]],["impl Unpin for INITPROC",1,["os::task::INITPROC"]],["impl Unpin for TrapContext",1,["os::trap::context::TrapContext"]]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/ops/arith/trait.Sub.js b/ch5/implementors/core/ops/arith/trait.Sub.js index e8fee344..1be45d45 100644 --- a/ch5/implementors/core/ops/arith/trait.Sub.js +++ b/ch5/implementors/core/ops/arith/trait.Sub.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl Sub<MapPermission> for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl Sub<PTEFlags> for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl Sub<MapPermission> for MapPermission"],["impl Sub<PTEFlags> for PTEFlags"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/ops/arith/trait.SubAssign.js b/ch5/implementors/core/ops/arith/trait.SubAssign.js index eeea4dea..57c9deb5 100644 --- a/ch5/implementors/core/ops/arith/trait.SubAssign.js +++ b/ch5/implementors/core/ops/arith/trait.SubAssign.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl SubAssign<MapPermission> for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl SubAssign<PTEFlags> for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl SubAssign<PTEFlags> for PTEFlags"],["impl SubAssign<MapPermission> for MapPermission"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/ops/bit/trait.BitAnd.js b/ch5/implementors/core/ops/bit/trait.BitAnd.js index e5a4a43f..d4050ead 100644 --- a/ch5/implementors/core/ops/bit/trait.BitAnd.js +++ b/ch5/implementors/core/ops/bit/trait.BitAnd.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl BitAnd<MapPermission> for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl BitAnd<PTEFlags> for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl BitAnd<PTEFlags> for PTEFlags"],["impl BitAnd<MapPermission> for MapPermission"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/ops/bit/trait.BitAndAssign.js b/ch5/implementors/core/ops/bit/trait.BitAndAssign.js index d922a56a..58db7f9b 100644 --- a/ch5/implementors/core/ops/bit/trait.BitAndAssign.js +++ b/ch5/implementors/core/ops/bit/trait.BitAndAssign.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl BitAndAssign<MapPermission> for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl BitAndAssign<PTEFlags> for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl BitAndAssign<PTEFlags> for PTEFlags"],["impl BitAndAssign<MapPermission> for MapPermission"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/ops/bit/trait.BitOr.js b/ch5/implementors/core/ops/bit/trait.BitOr.js index d9be1d89..243f6304 100644 --- a/ch5/implementors/core/ops/bit/trait.BitOr.js +++ b/ch5/implementors/core/ops/bit/trait.BitOr.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl BitOr<MapPermission> for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl BitOr<PTEFlags> for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl BitOr<MapPermission> for MapPermission"],["impl BitOr<PTEFlags> for PTEFlags"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/ops/bit/trait.BitOrAssign.js b/ch5/implementors/core/ops/bit/trait.BitOrAssign.js index 81aa0e5a..317c2cb9 100644 --- a/ch5/implementors/core/ops/bit/trait.BitOrAssign.js +++ b/ch5/implementors/core/ops/bit/trait.BitOrAssign.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl BitOrAssign<MapPermission> for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl BitOrAssign<PTEFlags> for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl BitOrAssign<MapPermission> for MapPermission"],["impl BitOrAssign<PTEFlags> for PTEFlags"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/ops/bit/trait.BitXor.js b/ch5/implementors/core/ops/bit/trait.BitXor.js index 617e24a1..3d1ad1c2 100644 --- a/ch5/implementors/core/ops/bit/trait.BitXor.js +++ b/ch5/implementors/core/ops/bit/trait.BitXor.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl BitXor<MapPermission> for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl BitXor<PTEFlags> for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl BitXor<PTEFlags> for PTEFlags"],["impl BitXor<MapPermission> for MapPermission"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/ops/bit/trait.BitXorAssign.js b/ch5/implementors/core/ops/bit/trait.BitXorAssign.js index a93c80ab..eafc4a75 100644 --- a/ch5/implementors/core/ops/bit/trait.BitXorAssign.js +++ b/ch5/implementors/core/ops/bit/trait.BitXorAssign.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl BitXorAssign<MapPermission> for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl BitXorAssign<PTEFlags> for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl BitXorAssign<MapPermission> for MapPermission"],["impl BitXorAssign<PTEFlags> for PTEFlags"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/ops/bit/trait.Not.js b/ch5/implementors/core/ops/bit/trait.Not.js index dbcdf767..46339266 100644 --- a/ch5/implementors/core/ops/bit/trait.Not.js +++ b/ch5/implementors/core/ops/bit/trait.Not.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl Not for MapPermission","synthetic":false,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl Not for PTEFlags","synthetic":false,"types":["os::mm::page_table::PTEFlags"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl Not for PTEFlags"],["impl Not for MapPermission"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/ops/deref/trait.Deref.js b/ch5/implementors/core/ops/deref/trait.Deref.js index b56d7c83..0cc32c18 100644 --- a/ch5/implementors/core/ops/deref/trait.Deref.js +++ b/ch5/implementors/core/ops/deref/trait.Deref.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl Deref for APP_NAMES","synthetic":false,"types":["os::loader::APP_NAMES"]},{"text":"impl Deref for FRAME_ALLOCATOR","synthetic":false,"types":["os::mm::frame_allocator::FRAME_ALLOCATOR"]},{"text":"impl Deref for KERNEL_SPACE","synthetic":false,"types":["os::mm::memory_set::KERNEL_SPACE"]},{"text":"impl Deref for TASK_MANAGER","synthetic":false,"types":["os::task::manager::TASK_MANAGER"]},{"text":"impl Deref for PID_ALLOCATOR","synthetic":false,"types":["os::task::pid::PID_ALLOCATOR"]},{"text":"impl Deref for PROCESSOR","synthetic":false,"types":["os::task::processor::PROCESSOR"]},{"text":"impl Deref for INITPROC","synthetic":false,"types":["os::task::INITPROC"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl Deref for FRAME_ALLOCATOR"],["impl Deref for TASK_MANAGER"],["impl Deref for INITPROC"],["impl Deref for KERNEL_SPACE"],["impl Deref for PROCESSOR"],["impl Deref for PID_ALLOCATOR"],["impl Deref for APP_NAMES"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/ops/drop/trait.Drop.js b/ch5/implementors/core/ops/drop/trait.Drop.js index 3c6fba4e..4b94f2ec 100644 --- a/ch5/implementors/core/ops/drop/trait.Drop.js +++ b/ch5/implementors/core/ops/drop/trait.Drop.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl Drop for FrameTracker","synthetic":false,"types":["os::mm::frame_allocator::FrameTracker"]},{"text":"impl Drop for PidHandle","synthetic":false,"types":["os::task::pid::PidHandle"]},{"text":"impl Drop for KernelStack","synthetic":false,"types":["os::task::pid::KernelStack"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl Drop for FrameTracker"],["impl Drop for PidHandle"],["impl Drop for KernelStack"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/panic/unwind_safe/trait.RefUnwindSafe.js b/ch5/implementors/core/panic/unwind_safe/trait.RefUnwindSafe.js index 2307211c..118adc40 100644 --- a/ch5/implementors/core/panic/unwind_safe/trait.RefUnwindSafe.js +++ b/ch5/implementors/core/panic/unwind_safe/trait.RefUnwindSafe.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl RefUnwindSafe for Stdout","synthetic":true,"types":["os::console::Stdout"]},{"text":"impl RefUnwindSafe for APP_NAMES","synthetic":true,"types":["os::loader::APP_NAMES"]},{"text":"impl RefUnwindSafe for PhysAddr","synthetic":true,"types":["os::mm::address::PhysAddr"]},{"text":"impl RefUnwindSafe for VirtAddr","synthetic":true,"types":["os::mm::address::VirtAddr"]},{"text":"impl RefUnwindSafe for PhysPageNum","synthetic":true,"types":["os::mm::address::PhysPageNum"]},{"text":"impl RefUnwindSafe for VirtPageNum","synthetic":true,"types":["os::mm::address::VirtPageNum"]},{"text":"impl<T> RefUnwindSafe for SimpleRange<T> where
    T: RefUnwindSafe, ","synthetic":true,"types":["os::mm::address::SimpleRange"]},{"text":"impl<T> RefUnwindSafe for SimpleRangeIterator<T> where
    T: RefUnwindSafe, ","synthetic":true,"types":["os::mm::address::SimpleRangeIterator"]},{"text":"impl RefUnwindSafe for FrameTracker","synthetic":true,"types":["os::mm::frame_allocator::FrameTracker"]},{"text":"impl RefUnwindSafe for StackFrameAllocator","synthetic":true,"types":["os::mm::frame_allocator::StackFrameAllocator"]},{"text":"impl RefUnwindSafe for FRAME_ALLOCATOR","synthetic":true,"types":["os::mm::frame_allocator::FRAME_ALLOCATOR"]},{"text":"impl RefUnwindSafe for KERNEL_SPACE","synthetic":true,"types":["os::mm::memory_set::KERNEL_SPACE"]},{"text":"impl RefUnwindSafe for MemorySet","synthetic":true,"types":["os::mm::memory_set::MemorySet"]},{"text":"impl RefUnwindSafe for MapArea","synthetic":true,"types":["os::mm::memory_set::MapArea"]},{"text":"impl RefUnwindSafe for MapType","synthetic":true,"types":["os::mm::memory_set::MapType"]},{"text":"impl RefUnwindSafe for MapPermission","synthetic":true,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl RefUnwindSafe for PTEFlags","synthetic":true,"types":["os::mm::page_table::PTEFlags"]},{"text":"impl RefUnwindSafe for PageTableEntry","synthetic":true,"types":["os::mm::page_table::PageTableEntry"]},{"text":"impl RefUnwindSafe for PageTable","synthetic":true,"types":["os::mm::page_table::PageTable"]},{"text":"impl<T> !RefUnwindSafe for UPSafeCell<T>","synthetic":true,"types":["os::sync::up::UPSafeCell"]},{"text":"impl RefUnwindSafe for TaskContext","synthetic":true,"types":["os::task::context::TaskContext"]},{"text":"impl !RefUnwindSafe for TaskManager","synthetic":true,"types":["os::task::manager::TaskManager"]},{"text":"impl RefUnwindSafe for TASK_MANAGER","synthetic":true,"types":["os::task::manager::TASK_MANAGER"]},{"text":"impl RefUnwindSafe for PidAllocator","synthetic":true,"types":["os::task::pid::PidAllocator"]},{"text":"impl RefUnwindSafe for PID_ALLOCATOR","synthetic":true,"types":["os::task::pid::PID_ALLOCATOR"]},{"text":"impl RefUnwindSafe for PidHandle","synthetic":true,"types":["os::task::pid::PidHandle"]},{"text":"impl RefUnwindSafe for KernelStack","synthetic":true,"types":["os::task::pid::KernelStack"]},{"text":"impl !RefUnwindSafe for Processor","synthetic":true,"types":["os::task::processor::Processor"]},{"text":"impl RefUnwindSafe for PROCESSOR","synthetic":true,"types":["os::task::processor::PROCESSOR"]},{"text":"impl !RefUnwindSafe for TaskControlBlock","synthetic":true,"types":["os::task::task::TaskControlBlock"]},{"text":"impl !RefUnwindSafe for TaskControlBlockInner","synthetic":true,"types":["os::task::task::TaskControlBlockInner"]},{"text":"impl RefUnwindSafe for TaskStatus","synthetic":true,"types":["os::task::task::TaskStatus"]},{"text":"impl RefUnwindSafe for INITPROC","synthetic":true,"types":["os::task::INITPROC"]},{"text":"impl RefUnwindSafe for TrapContext","synthetic":true,"types":["os::trap::context::TrapContext"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl RefUnwindSafe for Stdout",1,["os::console::Stdout"]],["impl RefUnwindSafe for APP_NAMES",1,["os::loader::APP_NAMES"]],["impl RefUnwindSafe for PhysAddr",1,["os::mm::address::PhysAddr"]],["impl RefUnwindSafe for VirtAddr",1,["os::mm::address::VirtAddr"]],["impl RefUnwindSafe for PhysPageNum",1,["os::mm::address::PhysPageNum"]],["impl RefUnwindSafe for VirtPageNum",1,["os::mm::address::VirtPageNum"]],["impl<T> RefUnwindSafe for SimpleRange<T>where\n T: RefUnwindSafe,",1,["os::mm::address::SimpleRange"]],["impl<T> RefUnwindSafe for SimpleRangeIterator<T>where\n T: RefUnwindSafe,",1,["os::mm::address::SimpleRangeIterator"]],["impl RefUnwindSafe for FrameTracker",1,["os::mm::frame_allocator::FrameTracker"]],["impl RefUnwindSafe for StackFrameAllocator",1,["os::mm::frame_allocator::StackFrameAllocator"]],["impl RefUnwindSafe for FRAME_ALLOCATOR",1,["os::mm::frame_allocator::FRAME_ALLOCATOR"]],["impl RefUnwindSafe for KERNEL_SPACE",1,["os::mm::memory_set::KERNEL_SPACE"]],["impl RefUnwindSafe for MemorySet",1,["os::mm::memory_set::MemorySet"]],["impl RefUnwindSafe for MapArea",1,["os::mm::memory_set::MapArea"]],["impl RefUnwindSafe for MapType",1,["os::mm::memory_set::MapType"]],["impl RefUnwindSafe for MapPermission",1,["os::mm::memory_set::MapPermission"]],["impl RefUnwindSafe for PTEFlags",1,["os::mm::page_table::PTEFlags"]],["impl RefUnwindSafe for PageTableEntry",1,["os::mm::page_table::PageTableEntry"]],["impl RefUnwindSafe for PageTable",1,["os::mm::page_table::PageTable"]],["impl<T> !RefUnwindSafe for UPSafeCell<T>",1,["os::sync::up::UPSafeCell"]],["impl RefUnwindSafe for TaskContext",1,["os::task::context::TaskContext"]],["impl !RefUnwindSafe for TaskManager",1,["os::task::manager::TaskManager"]],["impl RefUnwindSafe for TASK_MANAGER",1,["os::task::manager::TASK_MANAGER"]],["impl RefUnwindSafe for PidAllocator",1,["os::task::pid::PidAllocator"]],["impl RefUnwindSafe for PID_ALLOCATOR",1,["os::task::pid::PID_ALLOCATOR"]],["impl RefUnwindSafe for PidHandle",1,["os::task::pid::PidHandle"]],["impl RefUnwindSafe for KernelStack",1,["os::task::pid::KernelStack"]],["impl !RefUnwindSafe for Processor",1,["os::task::processor::Processor"]],["impl RefUnwindSafe for PROCESSOR",1,["os::task::processor::PROCESSOR"]],["impl !RefUnwindSafe for TaskControlBlock",1,["os::task::task::TaskControlBlock"]],["impl !RefUnwindSafe for TaskControlBlockInner",1,["os::task::task::TaskControlBlockInner"]],["impl RefUnwindSafe for TaskStatus",1,["os::task::task::TaskStatus"]],["impl RefUnwindSafe for INITPROC",1,["os::task::INITPROC"]],["impl RefUnwindSafe for TrapContext",1,["os::trap::context::TrapContext"]]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/core/panic/unwind_safe/trait.UnwindSafe.js b/ch5/implementors/core/panic/unwind_safe/trait.UnwindSafe.js index e9023ef5..b00dd16e 100644 --- a/ch5/implementors/core/panic/unwind_safe/trait.UnwindSafe.js +++ b/ch5/implementors/core/panic/unwind_safe/trait.UnwindSafe.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl UnwindSafe for Stdout","synthetic":true,"types":["os::console::Stdout"]},{"text":"impl UnwindSafe for APP_NAMES","synthetic":true,"types":["os::loader::APP_NAMES"]},{"text":"impl UnwindSafe for PhysAddr","synthetic":true,"types":["os::mm::address::PhysAddr"]},{"text":"impl UnwindSafe for VirtAddr","synthetic":true,"types":["os::mm::address::VirtAddr"]},{"text":"impl UnwindSafe for PhysPageNum","synthetic":true,"types":["os::mm::address::PhysPageNum"]},{"text":"impl UnwindSafe for VirtPageNum","synthetic":true,"types":["os::mm::address::VirtPageNum"]},{"text":"impl<T> UnwindSafe for SimpleRange<T> where
    T: UnwindSafe, ","synthetic":true,"types":["os::mm::address::SimpleRange"]},{"text":"impl<T> UnwindSafe for SimpleRangeIterator<T> where
    T: UnwindSafe, ","synthetic":true,"types":["os::mm::address::SimpleRangeIterator"]},{"text":"impl UnwindSafe for FrameTracker","synthetic":true,"types":["os::mm::frame_allocator::FrameTracker"]},{"text":"impl UnwindSafe for StackFrameAllocator","synthetic":true,"types":["os::mm::frame_allocator::StackFrameAllocator"]},{"text":"impl UnwindSafe for FRAME_ALLOCATOR","synthetic":true,"types":["os::mm::frame_allocator::FRAME_ALLOCATOR"]},{"text":"impl UnwindSafe for KERNEL_SPACE","synthetic":true,"types":["os::mm::memory_set::KERNEL_SPACE"]},{"text":"impl UnwindSafe for MemorySet","synthetic":true,"types":["os::mm::memory_set::MemorySet"]},{"text":"impl UnwindSafe for MapArea","synthetic":true,"types":["os::mm::memory_set::MapArea"]},{"text":"impl UnwindSafe for MapType","synthetic":true,"types":["os::mm::memory_set::MapType"]},{"text":"impl UnwindSafe for MapPermission","synthetic":true,"types":["os::mm::memory_set::MapPermission"]},{"text":"impl UnwindSafe for PTEFlags","synthetic":true,"types":["os::mm::page_table::PTEFlags"]},{"text":"impl UnwindSafe for PageTableEntry","synthetic":true,"types":["os::mm::page_table::PageTableEntry"]},{"text":"impl UnwindSafe for PageTable","synthetic":true,"types":["os::mm::page_table::PageTable"]},{"text":"impl<T> UnwindSafe for UPSafeCell<T> where
    T: UnwindSafe, ","synthetic":true,"types":["os::sync::up::UPSafeCell"]},{"text":"impl UnwindSafe for TaskContext","synthetic":true,"types":["os::task::context::TaskContext"]},{"text":"impl !UnwindSafe for TaskManager","synthetic":true,"types":["os::task::manager::TaskManager"]},{"text":"impl UnwindSafe for TASK_MANAGER","synthetic":true,"types":["os::task::manager::TASK_MANAGER"]},{"text":"impl UnwindSafe for PidAllocator","synthetic":true,"types":["os::task::pid::PidAllocator"]},{"text":"impl UnwindSafe for PID_ALLOCATOR","synthetic":true,"types":["os::task::pid::PID_ALLOCATOR"]},{"text":"impl UnwindSafe for PidHandle","synthetic":true,"types":["os::task::pid::PidHandle"]},{"text":"impl UnwindSafe for KernelStack","synthetic":true,"types":["os::task::pid::KernelStack"]},{"text":"impl !UnwindSafe for Processor","synthetic":true,"types":["os::task::processor::Processor"]},{"text":"impl UnwindSafe for PROCESSOR","synthetic":true,"types":["os::task::processor::PROCESSOR"]},{"text":"impl !UnwindSafe for TaskControlBlock","synthetic":true,"types":["os::task::task::TaskControlBlock"]},{"text":"impl !UnwindSafe for TaskControlBlockInner","synthetic":true,"types":["os::task::task::TaskControlBlockInner"]},{"text":"impl UnwindSafe for TaskStatus","synthetic":true,"types":["os::task::task::TaskStatus"]},{"text":"impl UnwindSafe for INITPROC","synthetic":true,"types":["os::task::INITPROC"]},{"text":"impl UnwindSafe for TrapContext","synthetic":true,"types":["os::trap::context::TrapContext"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl UnwindSafe for Stdout",1,["os::console::Stdout"]],["impl UnwindSafe for APP_NAMES",1,["os::loader::APP_NAMES"]],["impl UnwindSafe for PhysAddr",1,["os::mm::address::PhysAddr"]],["impl UnwindSafe for VirtAddr",1,["os::mm::address::VirtAddr"]],["impl UnwindSafe for PhysPageNum",1,["os::mm::address::PhysPageNum"]],["impl UnwindSafe for VirtPageNum",1,["os::mm::address::VirtPageNum"]],["impl<T> UnwindSafe for SimpleRange<T>where\n T: UnwindSafe,",1,["os::mm::address::SimpleRange"]],["impl<T> UnwindSafe for SimpleRangeIterator<T>where\n T: UnwindSafe,",1,["os::mm::address::SimpleRangeIterator"]],["impl UnwindSafe for FrameTracker",1,["os::mm::frame_allocator::FrameTracker"]],["impl UnwindSafe for StackFrameAllocator",1,["os::mm::frame_allocator::StackFrameAllocator"]],["impl UnwindSafe for FRAME_ALLOCATOR",1,["os::mm::frame_allocator::FRAME_ALLOCATOR"]],["impl UnwindSafe for KERNEL_SPACE",1,["os::mm::memory_set::KERNEL_SPACE"]],["impl UnwindSafe for MemorySet",1,["os::mm::memory_set::MemorySet"]],["impl UnwindSafe for MapArea",1,["os::mm::memory_set::MapArea"]],["impl UnwindSafe for MapType",1,["os::mm::memory_set::MapType"]],["impl UnwindSafe for MapPermission",1,["os::mm::memory_set::MapPermission"]],["impl UnwindSafe for PTEFlags",1,["os::mm::page_table::PTEFlags"]],["impl UnwindSafe for PageTableEntry",1,["os::mm::page_table::PageTableEntry"]],["impl UnwindSafe for PageTable",1,["os::mm::page_table::PageTable"]],["impl<T> UnwindSafe for UPSafeCell<T>where\n T: UnwindSafe,",1,["os::sync::up::UPSafeCell"]],["impl UnwindSafe for TaskContext",1,["os::task::context::TaskContext"]],["impl !UnwindSafe for TaskManager",1,["os::task::manager::TaskManager"]],["impl UnwindSafe for TASK_MANAGER",1,["os::task::manager::TASK_MANAGER"]],["impl UnwindSafe for PidAllocator",1,["os::task::pid::PidAllocator"]],["impl UnwindSafe for PID_ALLOCATOR",1,["os::task::pid::PID_ALLOCATOR"]],["impl UnwindSafe for PidHandle",1,["os::task::pid::PidHandle"]],["impl UnwindSafe for KernelStack",1,["os::task::pid::KernelStack"]],["impl !UnwindSafe for Processor",1,["os::task::processor::Processor"]],["impl UnwindSafe for PROCESSOR",1,["os::task::processor::PROCESSOR"]],["impl !UnwindSafe for TaskControlBlock",1,["os::task::task::TaskControlBlock"]],["impl !UnwindSafe for TaskControlBlockInner",1,["os::task::task::TaskControlBlockInner"]],["impl UnwindSafe for TaskStatus",1,["os::task::task::TaskStatus"]],["impl UnwindSafe for INITPROC",1,["os::task::INITPROC"]],["impl UnwindSafe for TrapContext",1,["os::trap::context::TrapContext"]]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/lazy_static/trait.LazyStatic.js b/ch5/implementors/lazy_static/trait.LazyStatic.js index d8b51f52..3dedbd12 100644 --- a/ch5/implementors/lazy_static/trait.LazyStatic.js +++ b/ch5/implementors/lazy_static/trait.LazyStatic.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = [{"text":"impl LazyStatic for APP_NAMES","synthetic":false,"types":["os::loader::APP_NAMES"]},{"text":"impl LazyStatic for FRAME_ALLOCATOR","synthetic":false,"types":["os::mm::frame_allocator::FRAME_ALLOCATOR"]},{"text":"impl LazyStatic for KERNEL_SPACE","synthetic":false,"types":["os::mm::memory_set::KERNEL_SPACE"]},{"text":"impl LazyStatic for TASK_MANAGER","synthetic":false,"types":["os::task::manager::TASK_MANAGER"]},{"text":"impl LazyStatic for PID_ALLOCATOR","synthetic":false,"types":["os::task::pid::PID_ALLOCATOR"]},{"text":"impl LazyStatic for PROCESSOR","synthetic":false,"types":["os::task::processor::PROCESSOR"]},{"text":"impl LazyStatic for INITPROC","synthetic":false,"types":["os::task::INITPROC"]}]; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[["impl LazyStatic for APP_NAMES"],["impl LazyStatic for PID_ALLOCATOR"],["impl LazyStatic for KERNEL_SPACE"],["impl LazyStatic for TASK_MANAGER"],["impl LazyStatic for PROCESSOR"],["impl LazyStatic for INITPROC"],["impl LazyStatic for FRAME_ALLOCATOR"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/os/mm/address/trait.StepByOne.js b/ch5/implementors/os/mm/address/trait.StepByOne.js index 34fffcbd..f0f0a3ce 100644 --- a/ch5/implementors/os/mm/address/trait.StepByOne.js +++ b/ch5/implementors/os/mm/address/trait.StepByOne.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = []; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/implementors/os/mm/frame_allocator/trait.FrameAllocator.js b/ch5/implementors/os/mm/frame_allocator/trait.FrameAllocator.js index 34fffcbd..f0f0a3ce 100644 --- a/ch5/implementors/os/mm/frame_allocator/trait.FrameAllocator.js +++ b/ch5/implementors/os/mm/frame_allocator/trait.FrameAllocator.js @@ -1,3 +1,3 @@ -(function() {var implementors = {}; -implementors["os"] = []; -if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file +(function() {var implementors = { +"os":[] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/ch5/light.css b/ch5/light.css deleted file mode 100644 index a71085b0..00000000 --- a/ch5/light.css +++ /dev/null @@ -1 +0,0 @@ -:root{--main-background-color:white;--main-color:black;--settings-input-color:#2196f3;--sidebar-background-color:#F5F5F5;--sidebar-background-color-hover:#E0E0E0;--code-block-background-color:#F5F5F5;--scrollbar-track-background-color:#dcdcdc;--scrollbar-thumb-background-color:rgba(36,37,39,0.6);--scrollbar-color:rgba(36,37,39,0.6) #d9d9d9;--headings-border-bottom-color:#ddd;}.slider{background-color:#ccc;}.slider:before{background-color:white;}input:focus+.slider{box-shadow:0 0 0 2px #0a84ff,0 0 0 6px rgba(10,132,255,0.3);}.in-band{background-color:white;}.rust-logo{}.sidebar .current,.sidebar a:hover{background-color:#fff;}.line-numbers span{color:#c67e2d;}.line-numbers .line-highlighted{background-color:#FDFFD3 !important;}.docblock table td,.docblock table th{border-color:#ddd;}.search-results a:hover{background-color:#ddd;}.search-results a:focus{color:#000 !important;background-color:#ccc;}.search-results a:focus span{color:#000 !important;}a.result-trait:focus{background-color:#c7b6ff;}a.result-traitalias:focus{background-color:#c7b6ff;}a.result-mod:focus,a.result-externcrate:focus{background-color:#afc6e4;}a.result-enum:focus{background-color:#e7b1a0;}a.result-struct:focus{background-color:#e7b1a0;}a.result-union:focus{background-color:#e7b1a0;}a.result-fn:focus,a.result-method:focus,a.result-tymethod:focus{background-color:#c6afb3;}a.result-type:focus{background-color:#e7b1a0;}a.result-associatedtype:focus{background-color:#afc6e4;}a.result-foreigntype:focus{background-color:#e7b1a0;}a.result-attr:focus,a.result-derive:focus,a.result-macro:focus{background-color:#8ce488;}a.result-constant:focus,a.result-static:focus{background-color:#afc6e4;}a.result-primitive:focus{background-color:#e7b1a0;}a.result-keyword:focus{background-color:#afc6e4;}.content .item-info::before{color:#ccc;}.content span.enum,.content a.enum,.block a.current.enum{color:#AD378A;}.content span.struct,.content a.struct,.block a.current.struct{color:#AD378A;}.content span.type,.content a.type,.block a.current.type{color:#AD378A;}.content span.foreigntype,.content a.foreigntype,.block a.current.foreigntype{color:#3873AD;}.content span.associatedtype,.content a.associatedtype,.block a.current.associatedtype{color:#3873AD;}.content span.attr,.content a.attr,.block a.current.attr,.content span.derive,.content a.derive,.block a.current.derive,.content span.macro,.content a.macro,.block a.current.macro{color:#068000;}.content span.union,.content a.union,.block a.current.union{color:#AD378A;}.content span.constant,.content a.constant,.block a.current.constant,.content span.static,.content a.static,.block a.current.static{color:#3873AD;}.content span.primitive,.content a.primitive,.block a.current.primitive{color:#AD378A;}.content span.externcrate,.content span.mod,.content a.mod,.block a.current.mod{color:#3873AD;}.content span.trait,.content a.trait,.block a.current.trait{color:#6E4FC9;}.content span.traitalias,.content a.traitalias,.block a.current.traitalias{color:#5137AD;}.content span.fn,.content a.fn,.block a.current.fn,.content span.method,.content a.method,.block a.current.method,.content span.tymethod,.content a.tymethod,.block a.current.tymethod,.content .fnname{color:#AD7C37;}.content span.keyword,.content a.keyword,.block a.current.keyword{color:#3873AD;}.sidebar a{color:#356da4;}.sidebar a.current.enum{color:#a63283;}.sidebar a.current.struct{color:#a63283;}.sidebar a.current.type{color:#a63283;}.sidebar a.current.associatedtype{color:#356da4;}.sidebar a.current.foreigntype{color:#356da4;}.sidebar a.current.attr,.sidebar a.current.derive,.sidebar a.current.macro{color:#067901;}.sidebar a.current.union{color:#a63283;}.sidebar a.current.constant .sidebar a.current.static{color:#356da4;}.sidebar a.current.primitive{color:#a63283;}.sidebar a.current.externcrate .sidebar a.current.mod{color:#356da4;}.sidebar a.current.trait{color:#6849c3;}.sidebar a.current.traitalias{color:#4b349e;}.sidebar a.current.fn,.sidebar a.current.method,.sidebar a.current.tymethod{color:#a67736;}.sidebar a.current.keyword{color:#356da4;}nav.main .current{border-top-color:#000;border-bottom-color:#000;}nav.main .separator{border:1px solid #000;}a{color:#3873AD;}body.source .example-wrap pre.rust a{background:#eee;}details.rustdoc-toggle>summary.hideme>span,details.rustdoc-toggle>summary::before{color:#999;}#crate-search,.search-input{background-color:white;border-color:#e0e0e0;}#crate-search{border-color:#e0e0e0 !important;}.search-input:focus{border-color:#66afe9;}.stab.empty-impl{background:#FFF5D6;border-color:#FFC600;}.stab.unstable{background:#FFF5D6;border-color:#FFC600;}.stab.deprecated{background:#ffc4c4;border-color:#db7b7b;}.stab.must_implement{background:#F3DFFF;border-color:#b07bdb;}.stab.portability{background:#F3DFFF;border-color:#b07bdb;}.stab.portability>code{background:none;}.rightside,.out-of-band{color:grey;}.line-numbers :target{background-color:transparent;}pre.rust .kw{color:#8959A8;}pre.rust .kw-2,pre.rust .prelude-ty{color:#4271AE;}pre.rust .number,pre.rust .string{color:#718C00;}pre.rust .self,pre.rust .bool-val,pre.rust .prelude-val,pre.rust .attribute,pre.rust .attribute .ident{color:#C82829;}pre.rust .comment{color:#8E908C;}pre.rust .doccomment{color:#4D4D4C;}pre.rust .macro,pre.rust .macro-nonterminal{color:#3E999F;}pre.rust .lifetime{color:#B76514;}pre.rust .question-mark{color:#ff9011;}.example-wrap>pre.line-number{border-color:#c7c7c7;}a.test-arrow{color:#f5f5f5;background-color:rgba(78,139,202,0.2);}a.test-arrow:hover{background-color:#4e8bca;}.toggle-label,.code-attribute{color:#999;}:target{background:#FDFFD3;border-right:3px solid #AD7C37;}pre.compile_fail{border-left:2px solid rgba(255,0,0,.5);}pre.compile_fail:hover,.information:hover+pre.compile_fail{border-left:2px solid #f00;}pre.should_panic{border-left:2px solid rgba(255,0,0,.5);}pre.should_panic:hover,.information:hover+pre.should_panic{border-left:2px solid #f00;}pre.ignore{border-left:2px solid rgba(255,142,0,.6);}pre.ignore:hover,.information:hover+pre.ignore{border-left:2px solid #ff9200;}.tooltip.compile_fail{color:rgba(255,0,0,.5);}.information>.compile_fail:hover{color:#f00;}.tooltip.should_panic{color:rgba(255,0,0,.5);}.information>.should_panic:hover{color:#f00;}.tooltip.ignore{color:rgba(255,142,0,.6);}.information>.ignore:hover{color:#ff9200;}.search-failed a{color:#3873AD;}.tooltip::after{background-color:#000;color:#fff;}.tooltip::before{border-color:transparent black transparent transparent;}.notable-traits-tooltiptext{background-color:#eee;border-color:#999;}.notable-traits-tooltiptext .notable{border-bottom-color:#DDDDDD;}#titles>button:not(.selected){background-color:#e6e6e6;border-top-color:#e6e6e6;}#titles>button:hover,#titles>button.selected{background-color:#ffffff;border-top-color:#0089ff;}#titles>button>div.count{color:#888;}@media (max-width:700px){.sidebar-elems{border-right-color:#000;}}kbd{color:#000;background-color:#fafbfc;border-color:#d1d5da;border-bottom-color:#c6cbd1;box-shadow:inset 0 -1px 0 #c6cbd1;}#settings-menu>a,#help-button>button{border-color:#e0e0e0;background-color:#fff;}#settings-menu>a:hover,#settings-menu>a:focus,#help-button>button:hover,#help-button>button:focus{border-color:#717171;}.popover,.popover::before,#help-button span.top,#help-button span.bottom{border-color:#DDDDDD;}#copy-path{color:#999;}#copy-path>img{filter:invert(50%);}#copy-path:hover>img{filter:invert(35%);}#theme-choices{border-color:#ccc;background-color:#fff;}#theme-choices>button:not(:first-child){border-top-color:#e0e0e0;}#theme-choices>button:hover,#theme-choices>button:focus{background-color:#eee;}.search-results .result-name span.alias{color:#000;}.search-results .result-name span.grey{color:#999;}#source-sidebar>.title{border-bottom-color:#ccc;}#source-sidebar div.files>a:hover,details.dir-entry summary:hover,#source-sidebar div.files>a:focus,details.dir-entry summary:focus{background-color:#E0E0E0;}#source-sidebar div.files>a.selected{background-color:#fff;}.scraped-example-list .scrape-help{border-color:#555;color:#333;}.scraped-example-list .scrape-help:hover{border-color:black;color:black;}.more-examples-toggle summary,.more-examples-toggle .hide-more{color:#999;}.scraped-example .example-wrap .rust span.highlight{background:#fcffd6;}.scraped-example .example-wrap .rust span.highlight.focus{background:#f6fdb0;}.scraped-example:not(.expanded) .code-wrapper:before{background:linear-gradient(to bottom,rgba(255,255,255,1),rgba(255,255,255,0));}.scraped-example:not(.expanded) .code-wrapper:after{background:linear-gradient(to top,rgba(255,255,255,1),rgba(255,255,255,0));}.toggle-line-inner{background:#ccc;}.toggle-line:hover .toggle-line-inner{background:#999;} \ No newline at end of file diff --git a/ch5/main.js b/ch5/main.js deleted file mode 100644 index c2141ac5..00000000 --- a/ch5/main.js +++ /dev/null @@ -1,8 +0,0 @@ -"use strict";function getVar(name){const el=document.getElementById("rustdoc-vars");if(el){return el.attributes["data-"+name].value}else{return null}}function resourcePath(basename,extension){return getVar("root-path")+basename+getVar("resource-suffix")+extension}function hideMain(){addClass(document.getElementById(MAIN_ID),"hidden")}function showMain(){removeClass(document.getElementById(MAIN_ID),"hidden")}function elemIsInParent(elem,parent){while(elem&&elem!==document.body){if(elem===parent){return true}elem=elem.parentElement}return false}function blurHandler(event,parentElem,hideCallback){if(!elemIsInParent(document.activeElement,parentElem)&&!elemIsInParent(event.relatedTarget,parentElem)){hideCallback()}}(function(){window.rootPath=getVar("root-path");window.currentCrate=getVar("current-crate")}());function setMobileTopbar(){const mobileLocationTitle=document.querySelector(".mobile-topbar h2.location");const locationTitle=document.querySelector(".sidebar h2.location");if(mobileLocationTitle&&locationTitle){mobileLocationTitle.innerHTML=locationTitle.innerHTML}}function getVirtualKey(ev){if("key"in ev&&typeof ev.key!=="undefined"){return ev.key}const c=ev.charCode||ev.keyCode;if(c===27){return"Escape"}return String.fromCharCode(c)}const MAIN_ID="main-content";const SETTINGS_BUTTON_ID="settings-menu";const ALTERNATIVE_DISPLAY_ID="alternative-display";const NOT_DISPLAYED_ID="not-displayed";const HELP_BUTTON_ID="help-button";function getSettingsButton(){return document.getElementById(SETTINGS_BUTTON_ID)}function getHelpButton(){return document.getElementById(HELP_BUTTON_ID)}function getNakedUrl(){return window.location.href.split("?")[0].split("#")[0]}function insertAfter(newNode,referenceNode){referenceNode.parentNode.insertBefore(newNode,referenceNode.nextSibling)}function getOrCreateSection(id,classes){let el=document.getElementById(id);if(!el){el=document.createElement("section");el.id=id;el.className=classes;insertAfter(el,document.getElementById(MAIN_ID))}return el}function getAlternativeDisplayElem(){return getOrCreateSection(ALTERNATIVE_DISPLAY_ID,"content hidden")}function getNotDisplayedElem(){return getOrCreateSection(NOT_DISPLAYED_ID,"hidden")}function switchDisplayedElement(elemToDisplay){const el=getAlternativeDisplayElem();if(el.children.length>0){getNotDisplayedElem().appendChild(el.firstElementChild)}if(elemToDisplay===null){addClass(el,"hidden");showMain();return}el.appendChild(elemToDisplay);hideMain();removeClass(el,"hidden")}function browserSupportsHistoryApi(){return window.history&&typeof window.history.pushState==="function"}function loadCss(cssFileName){const link=document.createElement("link");link.href=resourcePath(cssFileName,".css");link.type="text/css";link.rel="stylesheet";document.getElementsByTagName("head")[0].appendChild(link)}(function(){function loadScript(url){const script=document.createElement("script");script.src=url;document.head.append(script)}getSettingsButton().onclick=event=>{addClass(getSettingsButton(),"rotate");event.preventDefault();loadCss("settings");loadScript(resourcePath("settings",".js"))};window.searchState={loadingText:"Loading search results...",input:document.getElementsByClassName("search-input")[0],outputElement:()=>{let el=document.getElementById("search");if(!el){el=document.createElement("section");el.id="search";getNotDisplayedElem().appendChild(el)}return el},title:document.title,titleBeforeSearch:document.title,timeout:null,currentTab:0,focusedByTab:[null,null,null],clearInputTimeout:()=>{if(searchState.timeout!==null){clearTimeout(searchState.timeout);searchState.timeout=null}},isDisplayed:()=>searchState.outputElement().parentElement.id===ALTERNATIVE_DISPLAY_ID,focus:()=>{searchState.input.focus()},defocus:()=>{searchState.input.blur()},showResults:search=>{if(search===null||typeof search==="undefined"){search=searchState.outputElement()}switchDisplayedElement(search);searchState.mouseMovedAfterSearch=false;document.title=searchState.title},hideResults:()=>{switchDisplayedElement(null);document.title=searchState.titleBeforeSearch;if(browserSupportsHistoryApi()){history.replaceState(null,window.currentCrate+" - Rust",getNakedUrl()+window.location.hash)}},getQueryStringParams:()=>{const params={};window.location.search.substring(1).split("&").map(s=>{const pair=s.split("=");params[decodeURIComponent(pair[0])]=typeof pair[1]==="undefined"?null:decodeURIComponent(pair[1])});return params},setup:()=>{const search_input=searchState.input;if(!searchState.input){return}let searchLoaded=false;function loadSearch(){if(!searchLoaded){searchLoaded=true;loadScript(resourcePath("search",".js"));loadScript(resourcePath("search-index",".js"))}}search_input.addEventListener("focus",()=>{search_input.origPlaceholder=search_input.placeholder;search_input.placeholder="Type your search here.";loadSearch()});if(search_input.value!==""){loadSearch()}const params=searchState.getQueryStringParams();if(params.search!==undefined){const search=searchState.outputElement();search.innerHTML="

"+searchState.loadingText+"

";searchState.showResults(search);loadSearch()}},};function getPageId(){if(window.location.hash){const tmp=window.location.hash.replace(/^#/,"");if(tmp.length>0){return tmp}}return null}const toggleAllDocsId="toggle-all-docs";let savedHash="";function handleHashes(ev){if(ev!==null&&searchState.isDisplayed()&&ev.newURL){switchDisplayedElement(null);const hash=ev.newURL.slice(ev.newURL.indexOf("#")+1);if(browserSupportsHistoryApi()){history.replaceState(null,"",getNakedUrl()+window.location.search+"#"+hash)}const elem=document.getElementById(hash);if(elem){elem.scrollIntoView()}}if(savedHash!==window.location.hash){savedHash=window.location.hash;if(savedHash.length===0){return}expandSection(savedHash.slice(1))}}function onHashChange(ev){const sidebar=document.getElementsByClassName("sidebar")[0];removeClass(sidebar,"shown");handleHashes(ev)}function openParentDetails(elem){while(elem){if(elem.tagName==="DETAILS"){elem.open=true}elem=elem.parentNode}}function expandSection(id){openParentDetails(document.getElementById(id))}function handleEscape(ev){searchState.clearInputTimeout();switchDisplayedElement(null);if(browserSupportsHistoryApi()){history.replaceState(null,window.currentCrate+" - Rust",getNakedUrl()+window.location.hash)}ev.preventDefault();searchState.defocus();window.hidePopoverMenus()}function handleShortcut(ev){const disableShortcuts=getSettingValue("disable-shortcuts")==="true";if(ev.ctrlKey||ev.altKey||ev.metaKey||disableShortcuts){return}if(document.activeElement.tagName==="INPUT"&&document.activeElement.type!=="checkbox"){switch(getVirtualKey(ev)){case"Escape":handleEscape(ev);break}}else{switch(getVirtualKey(ev)){case"Escape":handleEscape(ev);break;case"s":case"S":ev.preventDefault();searchState.focus();break;case"+":case"-":ev.preventDefault();toggleAllDocs();break;case"?":showHelp();break;default:break}}}document.addEventListener("keypress",handleShortcut);document.addEventListener("keydown",handleShortcut);function addSidebarItems(){if(!window.SIDEBAR_ITEMS){return}const sidebar=document.getElementsByClassName("sidebar-elems")[0];function block(shortty,id,longty){const filtered=window.SIDEBAR_ITEMS[shortty];if(!filtered){return}const div=document.createElement("div");div.className="block "+shortty;const h3=document.createElement("h3");h3.innerHTML=`${longty}`;div.appendChild(h3);const ul=document.createElement("ul");for(const item of filtered){const name=item[0];const desc=item[1];let klass=shortty;let path;if(shortty==="mod"){path=name+"/index.html"}else{path=shortty+"."+name+".html"}const current_page=document.location.href.split("/").pop();if(path===current_page){klass+=" current"}const link=document.createElement("a");link.href=path;link.title=desc;link.className=klass;link.textContent=name;const li=document.createElement("li");li.appendChild(link);ul.appendChild(li)}div.appendChild(ul);sidebar.appendChild(div)}if(sidebar){block("primitive","primitives","Primitive Types");block("mod","modules","Modules");block("macro","macros","Macros");block("struct","structs","Structs");block("enum","enums","Enums");block("union","unions","Unions");block("constant","constants","Constants");block("static","static","Statics");block("trait","traits","Traits");block("fn","functions","Functions");block("type","types","Type Definitions");block("foreigntype","foreign-types","Foreign Types");block("keyword","keywords","Keywords");block("traitalias","trait-aliases","Trait Aliases")}}window.register_implementors=imp=>{const implementors=document.getElementById("implementors-list");const synthetic_implementors=document.getElementById("synthetic-implementors-list");const inlined_types=new Set();if(synthetic_implementors){onEachLazy(synthetic_implementors.getElementsByClassName("impl"),el=>{const aliases=el.getAttribute("data-aliases");if(!aliases){return}aliases.split(",").forEach(alias=>{inlined_types.add(alias)})})}let currentNbImpls=implementors.getElementsByClassName("impl").length;const traitName=document.querySelector("h1.fqn > .in-band > .trait").textContent;const baseIdName="impl-"+traitName+"-";const libs=Object.getOwnPropertyNames(imp);const ignoreExternCrates=document.querySelector("script[data-ignore-extern-crates]").getAttribute("data-ignore-extern-crates");for(const lib of libs){if(lib===window.currentCrate||ignoreExternCrates.indexOf(lib)!==-1){continue}const structs=imp[lib];struct_loop:for(const struct of structs){const list=struct.synthetic?synthetic_implementors:implementors;if(struct.synthetic){for(const struct_type of struct.types){if(inlined_types.has(struct_type)){continue struct_loop}inlined_types.add(struct_type)}}const code=document.createElement("h3");code.innerHTML=struct.text;addClass(code,"code-header");addClass(code,"in-band");onEachLazy(code.getElementsByTagName("a"),elem=>{const href=elem.getAttribute("href");if(href&&href.indexOf("http")!==0){elem.setAttribute("href",window.rootPath+href)}});const currentId=baseIdName+currentNbImpls;const anchor=document.createElement("a");anchor.href="#"+currentId;addClass(anchor,"anchor");const display=document.createElement("div");display.id=currentId;addClass(display,"impl");display.appendChild(anchor);display.appendChild(code);list.appendChild(display);currentNbImpls+=1}}};if(window.pending_implementors){window.register_implementors(window.pending_implementors)}function addSidebarCrates(){if(!window.ALL_CRATES){return}const sidebarElems=document.getElementsByClassName("sidebar-elems")[0];if(!sidebarElems){return}const div=document.createElement("div");div.className="block crate";div.innerHTML="

Crates

";const ul=document.createElement("ul");div.appendChild(ul);for(const crate of window.ALL_CRATES){let klass="crate";if(window.rootPath!=="./"&&crate===window.currentCrate){klass+=" current"}const link=document.createElement("a");link.href=window.rootPath+crate+"/index.html";link.className=klass;link.textContent=crate;const li=document.createElement("li");li.appendChild(link);ul.appendChild(li)}sidebarElems.appendChild(div)}function labelForToggleButton(sectionIsCollapsed){if(sectionIsCollapsed){return"+"}return"\u2212"}function toggleAllDocs(){const innerToggle=document.getElementById(toggleAllDocsId);if(!innerToggle){return}let sectionIsCollapsed=false;if(hasClass(innerToggle,"will-expand")){removeClass(innerToggle,"will-expand");onEachLazy(document.getElementsByClassName("rustdoc-toggle"),e=>{if(!hasClass(e,"type-contents-toggle")){e.open=true}});innerToggle.title="collapse all docs"}else{addClass(innerToggle,"will-expand");onEachLazy(document.getElementsByClassName("rustdoc-toggle"),e=>{if(e.parentNode.id!=="implementations-list"||(!hasClass(e,"implementors-toggle")&&!hasClass(e,"type-contents-toggle"))){e.open=false}});sectionIsCollapsed=true;innerToggle.title="expand all docs"}innerToggle.children[0].innerText=labelForToggleButton(sectionIsCollapsed)}(function(){const toggles=document.getElementById(toggleAllDocsId);if(toggles){toggles.onclick=toggleAllDocs}const hideMethodDocs=getSettingValue("auto-hide-method-docs")==="true";const hideImplementations=getSettingValue("auto-hide-trait-implementations")==="true";const hideLargeItemContents=getSettingValue("auto-hide-large-items")!=="false";function setImplementorsTogglesOpen(id,open){const list=document.getElementById(id);if(list!==null){onEachLazy(list.getElementsByClassName("implementors-toggle"),e=>{e.open=open})}}if(hideImplementations){setImplementorsTogglesOpen("trait-implementations-list",false);setImplementorsTogglesOpen("blanket-implementations-list",false)}onEachLazy(document.getElementsByClassName("rustdoc-toggle"),e=>{if(!hideLargeItemContents&&hasClass(e,"type-contents-toggle")){e.open=true}if(hideMethodDocs&&hasClass(e,"method-toggle")){e.open=false}});const pageId=getPageId();if(pageId!==null){expandSection(pageId)}}());(function(){let lineNumbersFunc=()=>{};if(getSettingValue("line-numbers")==="true"){lineNumbersFunc=x=>{const count=x.textContent.split("\n").length;const elems=[];for(let i=0;i{if(hasClass(e,"compile_fail")){e.addEventListener("mouseover",function(){this.parentElement.previousElementSibling.childNodes[0].style.color="#f00"});e.addEventListener("mouseout",function(){this.parentElement.previousElementSibling.childNodes[0].style.color=""})}else if(hasClass(e,"ignore")){e.addEventListener("mouseover",function(){this.parentElement.previousElementSibling.childNodes[0].style.color="#ff9200"});e.addEventListener("mouseout",function(){this.parentElement.previousElementSibling.childNodes[0].style.color=""})}lineNumbersFunc(e)})}());function hideSidebar(){const sidebar=document.getElementsByClassName("sidebar")[0];removeClass(sidebar,"shown")}function handleClick(id,f){const elem=document.getElementById(id);if(elem){elem.addEventListener("click",f)}}handleClick(MAIN_ID,()=>{hideSidebar()});onEachLazy(document.getElementsByTagName("a"),el=>{if(el.hash){el.addEventListener("click",()=>{expandSection(el.hash.slice(1));hideSidebar()})}});onEachLazy(document.querySelectorAll(".rustdoc-toggle > summary:not(.hideme)"),el=>{el.addEventListener("click",e=>{if(e.target.tagName!=="SUMMARY"&&e.target.tagName!=="A"){e.preventDefault()}})});onEachLazy(document.getElementsByClassName("notable-traits"),e=>{e.onclick=function(){this.getElementsByClassName("notable-traits-tooltiptext")[0].classList.toggle("force-tooltip")}});const sidebar_menu_toggle=document.getElementsByClassName("sidebar-menu-toggle")[0];if(sidebar_menu_toggle){sidebar_menu_toggle.addEventListener("click",()=>{const sidebar=document.getElementsByClassName("sidebar")[0];if(!hasClass(sidebar,"shown")){addClass(sidebar,"shown")}else{removeClass(sidebar,"shown")}})}function helpBlurHandler(event){blurHandler(event,getHelpButton(),window.hidePopoverMenus)}function buildHelpMenu(){const book_info=document.createElement("span");book_info.className="top";book_info.innerHTML="You can find more information in \ - the rustdoc book.";const shortcuts=[["?","Show this help dialog"],["S","Focus the search field"],["↑","Move up in search results"],["↓","Move down in search results"],["← / →","Switch result tab (when results focused)"],["⏎","Go to active search result"],["+","Expand all sections"],["-","Collapse all sections"],].map(x=>"
"+x[0].split(" ").map((y,index)=>((index&1)===0?""+y+"":" "+y+" ")).join("")+"
"+x[1]+"
").join("");const div_shortcuts=document.createElement("div");addClass(div_shortcuts,"shortcuts");div_shortcuts.innerHTML="

Keyboard Shortcuts

"+shortcuts+"
";const infos=["Prefix searches with a type followed by a colon (e.g., fn:) to \ - restrict the search to a given item kind.","Accepted kinds are: fn, mod, struct, \ - enum, trait, type, macro, \ - and const.","Search functions by type signature (e.g., vec -> usize or \ - -> vec)","Search multiple things at once by splitting your query with comma (e.g., \ - str,u8 or String,struct:Vec,test)","You can look for items with an exact name by putting double quotes around \ - your request: \"string\"","Look for items inside another one by searching for a path: vec::Vec",].map(x=>"

"+x+"

").join("");const div_infos=document.createElement("div");addClass(div_infos,"infos");div_infos.innerHTML="

Search Tricks

"+infos;const rustdoc_version=document.createElement("span");rustdoc_version.className="bottom";const rustdoc_version_code=document.createElement("code");rustdoc_version_code.innerText="rustdoc "+getVar("rustdoc-version");rustdoc_version.appendChild(rustdoc_version_code);const container=document.createElement("div");container.className="popover";container.style.display="none";const side_by_side=document.createElement("div");side_by_side.className="side-by-side";side_by_side.appendChild(div_shortcuts);side_by_side.appendChild(div_infos);container.appendChild(book_info);container.appendChild(side_by_side);container.appendChild(rustdoc_version);const help_button=getHelpButton();help_button.appendChild(container);container.onblur=helpBlurHandler;container.onclick=event=>{event.preventDefault()};help_button.onblur=helpBlurHandler;help_button.children[0].onblur=helpBlurHandler;return container}window.hidePopoverMenus=function(){onEachLazy(document.querySelectorAll(".search-container .popover"),elem=>{elem.style.display="none"})};function getHelpMenu(buildNeeded){let menu=getHelpButton().querySelector(".popover");if(!menu&&buildNeeded){menu=buildHelpMenu()}return menu}function showHelp(){const menu=getHelpMenu(true);if(menu.style.display==="none"){window.hidePopoverMenus();menu.style.display=""}}document.querySelector(`#${HELP_BUTTON_ID} > button`).addEventListener("click",event=>{const target=event.target;if(target.tagName!=="BUTTON"||target.parentElement.id!==HELP_BUTTON_ID){return}const menu=getHelpMenu(true);const shouldShowHelp=menu.style.display==="none";if(shouldShowHelp){showHelp()}else{window.hidePopoverMenus()}});setMobileTopbar();addSidebarItems();addSidebarCrates();onHashChange(null);window.addEventListener("hashchange",onHashChange);searchState.setup()}());(function(){let reset_button_timeout=null;window.copy_path=but=>{const parent=but.parentElement;const path=[];onEach(parent.childNodes,child=>{if(child.tagName==="A"){path.push(child.textContent)}});const el=document.createElement("textarea");el.value=path.join("::");el.setAttribute("readonly","");el.style.position="absolute";el.style.left="-9999px";document.body.appendChild(el);el.select();document.execCommand("copy");document.body.removeChild(el);but.children[0].style.display="none";let tmp;if(but.childNodes.length<2){tmp=document.createTextNode("✓");but.appendChild(tmp)}else{onEachLazy(but.childNodes,e=>{if(e.nodeType===Node.TEXT_NODE){tmp=e;return true}});tmp.textContent="✓"}if(reset_button_timeout!==null){window.clearTimeout(reset_button_timeout)}function reset_button(){tmp.textContent="";reset_button_timeout=null;but.children[0].style.display=""}reset_button_timeout=window.setTimeout(reset_button,1000)}}()) \ No newline at end of file diff --git a/ch5/noscript.css b/ch5/noscript.css deleted file mode 100644 index d850bb38..00000000 --- a/ch5/noscript.css +++ /dev/null @@ -1 +0,0 @@ - #main-content .attributes{margin-left:0 !important;}#copy-path{display:none;}.sub{display:none;} \ No newline at end of file diff --git a/ch5/os/all.html b/ch5/os/all.html index 7a94006d..6e7e0c00 100644 --- a/ch5/os/all.html +++ b/ch5/os/all.html @@ -1 +1 @@ -List of all items in this crate

List of all items

Structs

Enums

Traits

Macros

Functions

Typedefs

Statics

Constants

\ No newline at end of file +List of all items in this crate

List of all items

Structs

Enums

Traits

Macros

Functions

Type Aliases

Statics

Constants

\ No newline at end of file diff --git a/ch5/os/board/constant.CLOCK_FREQ.html b/ch5/os/board/constant.CLOCK_FREQ.html index f2024d8e..3e1676e0 100644 --- a/ch5/os/board/constant.CLOCK_FREQ.html +++ b/ch5/os/board/constant.CLOCK_FREQ.html @@ -1 +1 @@ -CLOCK_FREQ in os::board - Rust

Constant os::board::CLOCK_FREQ

source · [−]
pub const CLOCK_FREQ: usize = 12500000;
\ No newline at end of file +CLOCK_FREQ in os::board - Rust

Constant os::board::CLOCK_FREQ

source · 
pub const CLOCK_FREQ: usize = 12500000;
\ No newline at end of file diff --git a/ch5/os/board/constant.MEMORY_END.html b/ch5/os/board/constant.MEMORY_END.html index e98a0651..5c31d603 100644 --- a/ch5/os/board/constant.MEMORY_END.html +++ b/ch5/os/board/constant.MEMORY_END.html @@ -1 +1 @@ -MEMORY_END in os::board - Rust

Constant os::board::MEMORY_END

source · [−]
pub const MEMORY_END: usize = 0x81000000;
\ No newline at end of file +MEMORY_END in os::board - Rust

Constant os::board::MEMORY_END

source · 
pub const MEMORY_END: usize = 0x81000000;
\ No newline at end of file diff --git a/ch5/os/board/constant.MMIO.html b/ch5/os/board/constant.MMIO.html index 00addc31..9a34afe5 100644 --- a/ch5/os/board/constant.MMIO.html +++ b/ch5/os/board/constant.MMIO.html @@ -1 +1 @@ -MMIO in os::board - Rust

Constant os::board::MMIO

source · [−]
pub const MMIO: &'static [(usize, usize)];
\ No newline at end of file +MMIO in os::board - Rust

Constant os::board::MMIO

source · 
pub const MMIO: &[(usize, usize)];
\ No newline at end of file diff --git a/ch5/os/board/index.html b/ch5/os/board/index.html index bcd3624f..5486b88b 100644 --- a/ch5/os/board/index.html +++ b/ch5/os/board/index.html @@ -1,2 +1,2 @@ -os::board - Rust

Module os::board

source · [−]
Expand description

Constants used in rCore for qemu

-

Constants

CLOCK_FREQ
MEMORY_END
MMIO
\ No newline at end of file +os::board - Rust

Module os::board

source ·
Expand description

Constants used in rCore for qemu

+

Constants

\ No newline at end of file diff --git a/ch5/os/board/sidebar-items.js b/ch5/os/board/sidebar-items.js index e3976a48..33627091 100644 --- a/ch5/os/board/sidebar-items.js +++ b/ch5/os/board/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"constant":[["CLOCK_FREQ",""],["MEMORY_END",""],["MMIO",""]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"constant":["CLOCK_FREQ","MEMORY_END","MMIO"]}; \ No newline at end of file diff --git a/ch5/os/config/constant.KERNEL_HEAP_SIZE.html b/ch5/os/config/constant.KERNEL_HEAP_SIZE.html index 6f217f01..d896bc92 100644 --- a/ch5/os/config/constant.KERNEL_HEAP_SIZE.html +++ b/ch5/os/config/constant.KERNEL_HEAP_SIZE.html @@ -1 +1 @@ -KERNEL_HEAP_SIZE in os::config - Rust

Constant os::config::KERNEL_HEAP_SIZE

source · [−]
pub const KERNEL_HEAP_SIZE: usize = 0x20_0000;
\ No newline at end of file +KERNEL_HEAP_SIZE in os::config - Rust

Constant os::config::KERNEL_HEAP_SIZE

source · 
pub const KERNEL_HEAP_SIZE: usize = 0x20_0000;
\ No newline at end of file diff --git a/ch5/os/config/constant.KERNEL_STACK_SIZE.html b/ch5/os/config/constant.KERNEL_STACK_SIZE.html index 1228603c..a3f6b7b5 100644 --- a/ch5/os/config/constant.KERNEL_STACK_SIZE.html +++ b/ch5/os/config/constant.KERNEL_STACK_SIZE.html @@ -1 +1 @@ -KERNEL_STACK_SIZE in os::config - Rust

Constant os::config::KERNEL_STACK_SIZE

source · [−]
pub const KERNEL_STACK_SIZE: usize = _; // 8_192usize
\ No newline at end of file +KERNEL_STACK_SIZE in os::config - Rust

Constant os::config::KERNEL_STACK_SIZE

source · 
pub const KERNEL_STACK_SIZE: usize = _; // 8_192usize
\ No newline at end of file diff --git a/ch5/os/config/constant.PAGE_SIZE.html b/ch5/os/config/constant.PAGE_SIZE.html index 48a439c6..136412c9 100644 --- a/ch5/os/config/constant.PAGE_SIZE.html +++ b/ch5/os/config/constant.PAGE_SIZE.html @@ -1 +1 @@ -PAGE_SIZE in os::config - Rust

Constant os::config::PAGE_SIZE

source · [−]
pub const PAGE_SIZE: usize = 0x1000;
\ No newline at end of file +PAGE_SIZE in os::config - Rust

Constant os::config::PAGE_SIZE

source · 
pub const PAGE_SIZE: usize = 0x1000;
\ No newline at end of file diff --git a/ch5/os/config/constant.PAGE_SIZE_BITS.html b/ch5/os/config/constant.PAGE_SIZE_BITS.html index 57ac1b14..d7d81636 100644 --- a/ch5/os/config/constant.PAGE_SIZE_BITS.html +++ b/ch5/os/config/constant.PAGE_SIZE_BITS.html @@ -1 +1 @@ -PAGE_SIZE_BITS in os::config - Rust

Constant os::config::PAGE_SIZE_BITS

source · [−]
pub const PAGE_SIZE_BITS: usize = 0xc;
\ No newline at end of file +PAGE_SIZE_BITS in os::config - Rust

Constant os::config::PAGE_SIZE_BITS

source · 
pub const PAGE_SIZE_BITS: usize = 0xc;
\ No newline at end of file diff --git a/ch5/os/config/constant.TRAMPOLINE.html b/ch5/os/config/constant.TRAMPOLINE.html index f4960828..f6ed8dd7 100644 --- a/ch5/os/config/constant.TRAMPOLINE.html +++ b/ch5/os/config/constant.TRAMPOLINE.html @@ -1 +1 @@ -TRAMPOLINE in os::config - Rust

Constant os::config::TRAMPOLINE

source · [−]
pub const TRAMPOLINE: usize = _; // 18_446_744_073_709_547_520usize
\ No newline at end of file +TRAMPOLINE in os::config - Rust

Constant os::config::TRAMPOLINE

source · 
pub const TRAMPOLINE: usize = _; // 18_446_744_073_709_547_520usize
\ No newline at end of file diff --git a/ch5/os/config/constant.TRAP_CONTEXT.html b/ch5/os/config/constant.TRAP_CONTEXT.html index ce6bd7d0..cf95eee6 100644 --- a/ch5/os/config/constant.TRAP_CONTEXT.html +++ b/ch5/os/config/constant.TRAP_CONTEXT.html @@ -1 +1 @@ -TRAP_CONTEXT in os::config - Rust

Constant os::config::TRAP_CONTEXT

source · [−]
pub const TRAP_CONTEXT: usize = _; // 18_446_744_073_709_543_424usize
\ No newline at end of file +TRAP_CONTEXT in os::config - Rust

Constant os::config::TRAP_CONTEXT

source · 
pub const TRAP_CONTEXT: usize = _; // 18_446_744_073_709_543_424usize
\ No newline at end of file diff --git a/ch5/os/config/constant.USER_STACK_SIZE.html b/ch5/os/config/constant.USER_STACK_SIZE.html index 05ad9d20..aa042520 100644 --- a/ch5/os/config/constant.USER_STACK_SIZE.html +++ b/ch5/os/config/constant.USER_STACK_SIZE.html @@ -1 +1 @@ -USER_STACK_SIZE in os::config - Rust

Constant os::config::USER_STACK_SIZE

source · [−]
pub const USER_STACK_SIZE: usize = _; // 8_192usize
\ No newline at end of file +USER_STACK_SIZE in os::config - Rust

Constant os::config::USER_STACK_SIZE

source · 
pub const USER_STACK_SIZE: usize = _; // 8_192usize
\ No newline at end of file diff --git a/ch5/os/config/index.html b/ch5/os/config/index.html index b7fcc442..2fc056b9 100644 --- a/ch5/os/config/index.html +++ b/ch5/os/config/index.html @@ -1,2 +1,2 @@ -os::config - Rust

Module os::config

source · [−]
Expand description

Constants used in rCore

-

Re-exports

pub use crate::board::CLOCK_FREQ;
pub use crate::board::MEMORY_END;
pub use crate::board::MMIO;

Constants

KERNEL_HEAP_SIZE
KERNEL_STACK_SIZE
PAGE_SIZE
PAGE_SIZE_BITS
TRAMPOLINE
TRAP_CONTEXT
USER_STACK_SIZE
\ No newline at end of file +os::config - Rust

Module os::config

source ·
Expand description

Constants used in rCore

+

Re-exports

Constants

\ No newline at end of file diff --git a/ch5/os/config/sidebar-items.js b/ch5/os/config/sidebar-items.js index 783ffaba..cd442118 100644 --- a/ch5/os/config/sidebar-items.js +++ b/ch5/os/config/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"constant":[["KERNEL_HEAP_SIZE",""],["KERNEL_STACK_SIZE",""],["PAGE_SIZE",""],["PAGE_SIZE_BITS",""],["TRAMPOLINE",""],["TRAP_CONTEXT",""],["USER_STACK_SIZE",""]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"constant":["KERNEL_HEAP_SIZE","KERNEL_STACK_SIZE","PAGE_SIZE","PAGE_SIZE_BITS","TRAMPOLINE","TRAP_CONTEXT","USER_STACK_SIZE"]}; \ No newline at end of file diff --git a/ch5/os/console/fn.print.html b/ch5/os/console/fn.print.html index 4229c073..536de6e6 100644 --- a/ch5/os/console/fn.print.html +++ b/ch5/os/console/fn.print.html @@ -1 +1 @@ -print in os::console - Rust

Function os::console::print

source · [−]
pub fn print(args: Arguments<'_>)
\ No newline at end of file +print in os::console - Rust

Function os::console::print

source · 
pub fn print(args: Arguments<'_>)
\ No newline at end of file diff --git a/ch5/os/console/index.html b/ch5/os/console/index.html index 4e2858a2..3ce314c2 100644 --- a/ch5/os/console/index.html +++ b/ch5/os/console/index.html @@ -1,2 +1,2 @@ -os::console - Rust

Module os::console

source · [−]
Expand description

SBI console driver, for text output

-

Structs

Stdout 🔒

Functions

print
\ No newline at end of file +os::console - Rust

Module os::console

source ·
Expand description

SBI console driver, for text output

+

Structs

Functions

\ No newline at end of file diff --git a/ch5/os/console/sidebar-items.js b/ch5/os/console/sidebar-items.js index cf66d5eb..d7b318cf 100644 --- a/ch5/os/console/sidebar-items.js +++ b/ch5/os/console/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"fn":[["print",""]],"struct":[["Stdout",""]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"fn":["print"],"struct":["Stdout"]}; \ No newline at end of file diff --git a/ch5/os/console/struct.Stdout.html b/ch5/os/console/struct.Stdout.html index 011dc852..2d4a4c8a 100644 --- a/ch5/os/console/struct.Stdout.html +++ b/ch5/os/console/struct.Stdout.html @@ -1,16 +1,12 @@ -Stdout in os::console - Rust

Struct os::console::Stdout

source · [−]
struct Stdout;

Trait Implementations

Writes a string slice into this writer, returning whether the write -succeeded. Read more

-

Writes a char into this writer, returning whether the write succeeded. Read more

-

Glue for usage of the write! macro with implementors of this trait. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Returns the argument unchanged.

-

Calls U::from(self).

+Stdout in os::console - Rust

Struct os::console::Stdout

source · 
struct Stdout;

Trait Implementations§

source§

impl Write for Stdout

source§

fn write_str(&mut self, s: &str) -> Result

Writes a string slice into this writer, returning whether the write +succeeded. Read more
1.1.0 · source§

fn write_char(&mut self, c: char) -> Result<(), Error>

Writes a char into this writer, returning whether the write succeeded. Read more
1.0.0 · source§

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Glue for usage of the write! macro with implementors of this trait. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for Twhere + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+
source§

impl<T, U> Into<U> for Twhere + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +From<T> for U chooses to do.

+
source§

impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
\ No newline at end of file diff --git a/ch5/os/fn.clear_bss.html b/ch5/os/fn.clear_bss.html index 10cd4435..8758187a 100644 --- a/ch5/os/fn.clear_bss.html +++ b/ch5/os/fn.clear_bss.html @@ -1,2 +1,2 @@ -clear_bss in os - Rust

Function os::clear_bss

source · [−]
pub(crate) fn clear_bss()
Expand description

clear BSS segment

-
\ No newline at end of file +clear_bss in os - Rust

Function os::clear_bss

source · 
pub(crate) fn clear_bss()
Expand description

clear BSS segment

+
\ No newline at end of file diff --git a/ch5/os/fn.rust_main.html b/ch5/os/fn.rust_main.html index 91ac6b63..185d4e1c 100644 --- a/ch5/os/fn.rust_main.html +++ b/ch5/os/fn.rust_main.html @@ -1,3 +1,3 @@ -rust_main in os - Rust

Function os::rust_main

source · [−]
#[no_mangle]
-pub fn rust_main() -> !
Expand description

the rust entry-point of os

-
\ No newline at end of file +rust_main in os - Rust

Function os::rust_main

source · 
#[no_mangle]
+pub fn rust_main() -> !
Expand description

the rust entry-point of os

+
\ No newline at end of file diff --git a/ch5/os/index.html b/ch5/os/index.html index 5dde4991..5aa3d9f8 100644 --- a/ch5/os/index.html +++ b/ch5/os/index.html @@ -1,33 +1,17 @@ -os - Rust

Crate os

source · [−]
Expand description

The main module and entrypoint

+os - Rust

Crate os

source ·
Expand description

The main module and entrypoint

Various facilities of the kernels are implemented as submodules. The most important ones are:

    -
  • trap: Handles all cases of switching from userspace to the kernel
    • -
  • task: Task management
    • -
  • syscall: System call handling and implementation
    • -
  • mm: Address map using SV39
    • -
  • sync:Wrap a static data structure inside it so that we are able to access it without any unsafe.
    • +
  • trap: Handles all cases of switching from userspace to the kernel
    • +
  • task: Task management
    • +
  • syscall: System call handling and implementation
    • +
  • mm: Address map using SV39
    • +
  • sync:Wrap a static data structure inside it so that we are able to access it without any unsafe.

The operating system also starts in this module. Kernel code starts -executing from entry.asm, after which rust_main() is called to +executing from entry.asm, after which rust_main() is called to initialize various pieces of functionality. (See its source code for details.)

-

We then call task::run_tasks() and for the first time go to +

We then call task::run_tasks() and for the first time go to userspace.

-

Modules

board 🔒

Constants used in rCore for qemu

-
config 🔒

Constants used in rCore

-
console 🔒

SBI console driver, for text output

-
lang_items 🔒

The panic handler

-
loader 🔒

Loading user applications into memory

-
mm

Memory management implementation

-
sbi 🔒

SBI call wrappers

-
sync

Synchronization and interior mutability primitives

-
syscall

Implementation of syscalls

-
task

Task management implementation

-
timer 🔒

RISC-V timer-related functionality

-
trap

Trap handling functionality

-

Macros

print

print string macro

-
println

println string macro

-

Functions

clear_bss 🔒

clear BSS segment

-
rust_main

the rust entry-point of os

-
\ No newline at end of file +

Modules

  • board 🔒
    Constants used in rCore for qemu
  • config 🔒
    Constants used in rCore
  • console 🔒
    SBI console driver, for text output
  • lang_items 🔒
    The panic handler
  • loader 🔒
    Loading user applications into memory
  • mm
    Memory management implementation
  • sbi 🔒
    SBI call wrappers
  • sync
    Synchronization and interior mutability primitives
  • syscall
    Implementation of syscalls
  • task
    Task management implementation
  • timer 🔒
    RISC-V timer-related functionality
  • trap
    Trap handling functionality

Macros

Functions

\ No newline at end of file diff --git a/ch5/os/lang_items/fn.panic.html b/ch5/os/lang_items/fn.panic.html index ca270052..1479ac8f 100644 --- a/ch5/os/lang_items/fn.panic.html +++ b/ch5/os/lang_items/fn.panic.html @@ -1 +1 @@ -panic in os::lang_items - Rust

Function os::lang_items::panic

source · [−]
fn panic(info: &PanicInfo<'_>) -> !
\ No newline at end of file +panic in os::lang_items - Rust

Function os::lang_items::panic

source · 
fn panic(info: &PanicInfo<'_>) -> !
\ No newline at end of file diff --git a/ch5/os/lang_items/index.html b/ch5/os/lang_items/index.html index 6181316a..b82ab874 100644 --- a/ch5/os/lang_items/index.html +++ b/ch5/os/lang_items/index.html @@ -1,2 +1,2 @@ -os::lang_items - Rust

Module os::lang_items

source · [−]
Expand description

The panic handler

-

Functions

panic 🔒
\ No newline at end of file +os::lang_items - Rust

Module os::lang_items

source ·
Expand description

The panic handler

+

Functions

\ No newline at end of file diff --git a/ch5/os/lang_items/sidebar-items.js b/ch5/os/lang_items/sidebar-items.js index 65e8609b..6330d593 100644 --- a/ch5/os/lang_items/sidebar-items.js +++ b/ch5/os/lang_items/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"fn":[["panic",""]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"fn":["panic"]}; \ No newline at end of file diff --git a/ch5/os/loader/fn.get_app_data.html b/ch5/os/loader/fn.get_app_data.html index 80518911..5d767571 100644 --- a/ch5/os/loader/fn.get_app_data.html +++ b/ch5/os/loader/fn.get_app_data.html @@ -1,2 +1,2 @@ -get_app_data in os::loader - Rust

Function os::loader::get_app_data

source · [−]
pub fn get_app_data(app_id: usize) -> &'static [u8]
Expand description

get applications data

-
\ No newline at end of file +get_app_data in os::loader - Rust

Function os::loader::get_app_data

source · 
pub fn get_app_data(app_id: usize) -> &'static [u8]
Expand description

get applications data

+
\ No newline at end of file diff --git a/ch5/os/loader/fn.get_app_data_by_name.html b/ch5/os/loader/fn.get_app_data_by_name.html index c51f7cd8..24ead396 100644 --- a/ch5/os/loader/fn.get_app_data_by_name.html +++ b/ch5/os/loader/fn.get_app_data_by_name.html @@ -1,2 +1,2 @@ -get_app_data_by_name in os::loader - Rust

Function os::loader::get_app_data_by_name

source · [−]
pub fn get_app_data_by_name(name: &str) -> Option<&'static [u8]>
Expand description

get app data from name

-
\ No newline at end of file +get_app_data_by_name in os::loader - Rust

Function os::loader::get_app_data_by_name

source · 
pub fn get_app_data_by_name(name: &str) -> Option<&'static [u8]>
Expand description

get app data from name

+
\ No newline at end of file diff --git a/ch5/os/loader/fn.get_num_app.html b/ch5/os/loader/fn.get_num_app.html index 85dfda29..e44c11a9 100644 --- a/ch5/os/loader/fn.get_num_app.html +++ b/ch5/os/loader/fn.get_num_app.html @@ -1,2 +1,2 @@ -get_num_app in os::loader - Rust

Function os::loader::get_num_app

source · [−]
pub fn get_num_app() -> usize
Expand description

get app number

-
\ No newline at end of file +get_num_app in os::loader - Rust

Function os::loader::get_num_app

source · 
pub fn get_num_app() -> usize
Expand description

get app number

+
\ No newline at end of file diff --git a/ch5/os/loader/fn.list_apps.html b/ch5/os/loader/fn.list_apps.html index 1691a5c2..c53cbfc1 100644 --- a/ch5/os/loader/fn.list_apps.html +++ b/ch5/os/loader/fn.list_apps.html @@ -1,2 +1,2 @@ -list_apps in os::loader - Rust

Function os::loader::list_apps

source · [−]
pub fn list_apps()
Expand description

list all apps

-
\ No newline at end of file +list_apps in os::loader - Rust

Function os::loader::list_apps

source · 
pub fn list_apps()
Expand description

list all apps

+
\ No newline at end of file diff --git a/ch5/os/loader/index.html b/ch5/os/loader/index.html index 21029ebe..71fc2073 100644 --- a/ch5/os/loader/index.html +++ b/ch5/os/loader/index.html @@ -1,7 +1,2 @@ -os::loader - Rust

Module os::loader

source · [−]
Expand description

Loading user applications into memory

-

Structs

APP_NAMES 🔒

All of app’s name

-

Functions

get_app_data

get applications data

-
get_app_data_by_name

get app data from name

-
get_num_app

get app number

-
list_apps

list all apps

-
\ No newline at end of file +os::loader - Rust

Module os::loader

source ·
Expand description

Loading user applications into memory

+

Structs

Functions

\ No newline at end of file diff --git a/ch5/os/loader/sidebar-items.js b/ch5/os/loader/sidebar-items.js index 4fd41dee..ef180092 100644 --- a/ch5/os/loader/sidebar-items.js +++ b/ch5/os/loader/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"fn":[["get_app_data","get applications data"],["get_app_data_by_name","get app data from name"],["get_num_app","get app number"],["list_apps","list all apps"]],"struct":[["APP_NAMES","All of app’s name"]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"fn":["get_app_data","get_app_data_by_name","get_num_app","list_apps"],"struct":["APP_NAMES"]}; \ No newline at end of file diff --git a/ch5/os/loader/struct.APP_NAMES.html b/ch5/os/loader/struct.APP_NAMES.html index ee1ae11f..81b7d3d7 100644 --- a/ch5/os/loader/struct.APP_NAMES.html +++ b/ch5/os/loader/struct.APP_NAMES.html @@ -1,18 +1,19 @@ -APP_NAMES in os::loader - Rust

Struct os::loader::APP_NAMES

source · [−]
struct APP_NAMES {
+APP_NAMES in os::loader - Rust
Struct os::loader::APP_NAMES
source · 
struct APP_NAMES {
     __private_field: (),
-}
Expand description
All of app’s name

-
Fields
__private_field: ()
Methods from Deref<Target = Vec<&'static str>>
Returns the number of elements the vector can hold without
+}
Expand description

All of app’s name

+

Fields§

§__private_field: ()

Methods from Deref<Target = Vec<&'static str>>§

1.0.0 · source

pub fn capacity(&self) -> usize

Returns the total number of elements the vector can hold without reallocating.

Examples
-
let vec: Vec<i32> = Vec::with_capacity(10);
-assert_eq!(vec.capacity(), 10);
-

Extracts a slice containing the entire vector.

+
let mut vec: Vec<i32> = Vec::with_capacity(10);
+vec.push(42);
+assert!(vec.capacity() >= 10);
+
1.7.0 · source

pub fn as_slice(&self) -> &[T]

Extracts a slice containing the entire vector.

Equivalent to &s[..].

Examples
-
use std::io::{self, Write};
-let buffer = vec![1, 2, 3, 5, 8];
-io::sink().write(buffer.as_slice()).unwrap();
-

Returns a raw pointer to the vector’s buffer, or a dangling raw pointer +

use std::io::{self, Write};
+let buffer = vec![1, 2, 3, 5, 8];
+io::sink().write(buffer.as_slice()).unwrap();
+
1.37.0 · source

pub fn as_ptr(&self) -> *const T

Returns a raw pointer to the vector’s buffer, or a dangling raw pointer valid for zero sized reads if the vector didn’t allocate.

The caller must ensure that the vector outlives the pointer this function returns, or else it will end up pointing to garbage. @@ -20,166 +21,344 @@ Modifying the vector may cause its buffer to be reallocated, which would also make any pointers to it invalid.

The caller must also ensure that the memory the pointer (non-transitively) points to is never written to (except inside an UnsafeCell) using this pointer or any pointer -derived from it. If you need to mutate the contents of the slice, use as_mut_ptr.

+derived from it. If you need to mutate the contents of the slice, use as_mut_ptr.

+

This method guarantees that for the purpose of the aliasing model, this method +does not materialize a reference to the underlying slice, and thus the returned pointer +will remain valid when mixed with other calls to as_ptr and as_mut_ptr. +Note that calling other methods that materialize mutable references to the slice, +or mutable references to specific elements you are planning on accessing through this pointer, +as well as writing to those elements, may still invalidate this pointer. +See the second example below for how this guarantee can be used.

Examples
-
let x = vec![1, 2, 4];
-let x_ptr = x.as_ptr();
+
let x = vec![1, 2, 4];
+let x_ptr = x.as_ptr();
 
-unsafe {
-    for i in 0..x.len() {
-        assert_eq!(*x_ptr.add(i), 1 << i);
+unsafe {
+    for i in 0..x.len() {
+        assert_eq!(*x_ptr.add(i), 1 << i);
     }
 }

-
🔬 This is a nightly-only experimental API. (allocator_api)

Returns a reference to the underlying allocator.

-

Returns the number of elements in the vector, also referred to +

Due to the aliasing guarantee, the following code is legal:

+ +
unsafe {
+    let mut v = vec![0, 1, 2];
+    let ptr1 = v.as_ptr();
+    let _ = ptr1.read();
+    let ptr2 = v.as_mut_ptr().offset(2);
+    ptr2.write(2);
+    // Notably, the write to `ptr2` did *not* invalidate `ptr1`
+    // because it mutated a different element:
+    let _ = ptr1.read();
+}
+
source

pub fn allocator(&self) -> &A

🔬This is a nightly-only experimental API. (allocator_api)

Returns a reference to the underlying allocator.

+
1.0.0 · source

pub fn len(&self) -> usize

Returns the number of elements in the vector, also referred to as its ‘length’.

Examples
-
let a = vec![1, 2, 3];
-assert_eq!(a.len(), 3);
-

Returns true if the vector contains no elements.

+
let a = vec![1, 2, 3];
+assert_eq!(a.len(), 3);
+
1.0.0 · source

pub fn is_empty(&self) -> bool

Returns true if the vector contains no elements.

Examples
-
let mut v = Vec::new();
-assert!(v.is_empty());
+
let mut v = Vec::new();
+assert!(v.is_empty());
 
-v.push(1);
-assert!(!v.is_empty());

-

Methods from Deref<Target = [T]>

🔬 This is a nightly-only experimental API. (sort_floats)

Sorts the slice of floats.

-

This sort is in-place (i.e. does not allocate), O(n * log(n)) worst-case, and uses -the ordering defined by f64::total_cmp.

-
Current implementation
-

This uses the same sorting algorithm as sort_unstable_by.

-
Examples
-
#![feature(sort_floats)]
-let mut v = [2.6, -5e-8, f64::NAN, 8.29, f64::INFINITY, -1.0, 0.0, -f64::INFINITY, -0.0];
-
-v.sort_floats();
-let sorted = [-f64::INFINITY, -1.0, -5e-8, -0.0, 0.0, 2.6, 8.29, f64::INFINITY, f64::NAN];
-assert_eq!(&v[..8], &sorted[..8]);
-assert!(v[8].is_nan());
-

Checks if all bytes in this slice are within the ASCII range.

-

Checks that two slices are an ASCII case-insensitive match.

+v.push(1); +assert!(!v.is_empty());
+

Methods from Deref<Target = [T]>§

1.23.0 · source

pub fn is_ascii(&self) -> bool

Checks if all bytes in this slice are within the ASCII range.

+
source

pub fn as_ascii(&self) -> Option<&[AsciiChar]>

🔬This is a nightly-only experimental API. (ascii_char)

If this slice is_ascii, returns it as a slice of +ASCII characters, otherwise returns None.

+
source

pub unsafe fn as_ascii_unchecked(&self) -> &[AsciiChar]

🔬This is a nightly-only experimental API. (ascii_char)

Converts this slice of bytes into a slice of ASCII characters, +without checking whether they’re valid.

+
Safety
+

Every byte in the slice must be in 0..=127, or else this is UB.

+
1.23.0 · source

pub fn eq_ignore_ascii_case(&self, other: &[u8]) -> bool

Checks that two slices are an ASCII case-insensitive match.

Same as to_ascii_lowercase(a) == to_ascii_lowercase(b), but without allocating and copying temporaries.

-

Converts this slice to its ASCII upper case equivalent in-place.

+
1.23.0 · source

pub fn make_ascii_uppercase(&mut self)

Converts this slice to its ASCII upper case equivalent in-place.

ASCII letters ‘a’ to ‘z’ are mapped to ‘A’ to ‘Z’, but non-ASCII letters are unchanged.

To return a new uppercased value without modifying the existing one, use to_ascii_uppercase.

-

Converts this slice to its ASCII lower case equivalent in-place.

+
1.23.0 · source

pub fn make_ascii_lowercase(&mut self)

Converts this slice to its ASCII lower case equivalent in-place.

ASCII letters ‘A’ to ‘Z’ are mapped to ‘a’ to ‘z’, but non-ASCII letters are unchanged.

To return a new lowercased value without modifying the existing one, use to_ascii_lowercase.

-

Returns an iterator that produces an escaped version of this slice, +

1.60.0 · source

pub fn escape_ascii(&self) -> EscapeAscii<'_>

Returns an iterator that produces an escaped version of this slice, treating it as an ASCII string.

-
Examples
+
Examples

-let s = b"0\t\r\n'\"\\\x9d";
-let escaped = s.escape_ascii().to_string();
-assert_eq!(escaped, "0\\t\\r\\n\\'\\\"\\\\\\x9d");
-
🔬 This is a nightly-only experimental API. (byte_slice_trim_ascii)

Returns a byte slice with leading ASCII whitespace bytes removed.

+let s = b"0\t\r\n'\"\\\x9d"; +let escaped = s.escape_ascii().to_string(); +assert_eq!(escaped, "0\\t\\r\\n\\'\\\"\\\\\\x9d");
+
source

pub fn trim_ascii_start(&self) -> &[u8]

🔬This is a nightly-only experimental API. (byte_slice_trim_ascii)

Returns a byte slice with leading ASCII whitespace bytes removed.

+

‘Whitespace’ refers to the definition used by +u8::is_ascii_whitespace.

+
Examples
+
#![feature(byte_slice_trim_ascii)]
+
+assert_eq!(b" \t hello world\n".trim_ascii_start(), b"hello world\n");
+assert_eq!(b"  ".trim_ascii_start(), b"");
+assert_eq!(b"".trim_ascii_start(), b"");
+
source

pub fn trim_ascii_end(&self) -> &[u8]

🔬This is a nightly-only experimental API. (byte_slice_trim_ascii)

Returns a byte slice with trailing ASCII whitespace bytes removed.

‘Whitespace’ refers to the definition used by u8::is_ascii_whitespace.

Examples
-
#![feature(byte_slice_trim_ascii)]
+
#![feature(byte_slice_trim_ascii)]
 
-assert_eq!(b" \t hello world\n".trim_ascii_start(), b"hello world\n");
-assert_eq!(b"  ".trim_ascii_start(), b"");
-assert_eq!(b"".trim_ascii_start(), b"");

-
🔬 This is a nightly-only experimental API. (byte_slice_trim_ascii)

Returns a byte slice with trailing ASCII whitespace bytes removed.

-

‘Whitespace’ refers to the definition used by -u8::is_ascii_whitespace.

-
Examples
-
#![feature(byte_slice_trim_ascii)]
-
-assert_eq!(b"\r hello world\n ".trim_ascii_end(), b"\r hello world");
-assert_eq!(b"  ".trim_ascii_end(), b"");
-assert_eq!(b"".trim_ascii_end(), b"");
-
🔬 This is a nightly-only experimental API. (byte_slice_trim_ascii)

Returns a byte slice with leading and trailing ASCII whitespace bytes +assert_eq!(b"\r hello world\n ".trim_ascii_end(), b"\r hello world"); +assert_eq!(b" ".trim_ascii_end(), b""); +assert_eq!(b"".trim_ascii_end(), b"");

+
source

pub fn trim_ascii(&self) -> &[u8]

🔬This is a nightly-only experimental API. (byte_slice_trim_ascii)

Returns a byte slice with leading and trailing ASCII whitespace bytes removed.

‘Whitespace’ refers to the definition used by u8::is_ascii_whitespace.

+
Examples
+
#![feature(byte_slice_trim_ascii)]
+
+assert_eq!(b"\r hello world\n ".trim_ascii(), b"hello world");
+assert_eq!(b"  ".trim_ascii(), b"");
+assert_eq!(b"".trim_ascii(), b"");
+
source

pub fn sort_floats(&mut self)

🔬This is a nightly-only experimental API. (sort_floats)

Sorts the slice of floats.

+

This sort is in-place (i.e. does not allocate), O(n * log(n)) worst-case, and uses +the ordering defined by f64::total_cmp.

+
Current implementation
+

This uses the same sorting algorithm as sort_unstable_by.

Examples
-
#![feature(byte_slice_trim_ascii)]
+
#![feature(sort_floats)]
+let mut v = [2.6, -5e-8, f64::NAN, 8.29, f64::INFINITY, -1.0, 0.0, -f64::INFINITY, -0.0];
 
-assert_eq!(b"\r hello world\n ".trim_ascii(), b"hello world");
-assert_eq!(b"  ".trim_ascii(), b"");
-assert_eq!(b"".trim_ascii(), b"");

-

Returns the number of elements in the slice.

+v.sort_floats(); +let sorted = [-f64::INFINITY, -1.0, -5e-8, -0.0, 0.0, 2.6, 8.29, f64::INFINITY, f64::NAN]; +assert_eq!(&v[..8], &sorted[..8]); +assert!(v[8].is_nan());
+
source

pub fn flatten(&self) -> &[T]

🔬This is a nightly-only experimental API. (slice_flatten)

Takes a &[[T; N]], and flattens it to a &[T].

+
Panics
+

This panics if the length of the resulting slice would overflow a usize.

+

This is only possible when flattening a slice of arrays of zero-sized +types, and thus tends to be irrelevant in practice. If +size_of::<T>() > 0, this will never panic.

Examples
-
let a = [1, 2, 3];
-assert_eq!(a.len(), 3);
-

Returns true if the slice has a length of 0.

+
#![feature(slice_flatten)]
+
+assert_eq!([[1, 2, 3], [4, 5, 6]].flatten(), &[1, 2, 3, 4, 5, 6]);
+
+assert_eq!(
+    [[1, 2, 3], [4, 5, 6]].flatten(),
+    [[1, 2], [3, 4], [5, 6]].flatten(),
+);
+
+let slice_of_empty_arrays: &[[i32; 0]] = &[[], [], [], [], []];
+assert!(slice_of_empty_arrays.flatten().is_empty());
+
+let empty_slice_of_arrays: &[[u32; 10]] = &[];
+assert!(empty_slice_of_arrays.flatten().is_empty());
+
source

pub fn flatten_mut(&mut self) -> &mut [T]

🔬This is a nightly-only experimental API. (slice_flatten)

Takes a &mut [[T; N]], and flattens it to a &mut [T].

+
Panics
+

This panics if the length of the resulting slice would overflow a usize.

+

This is only possible when flattening a slice of arrays of zero-sized +types, and thus tends to be irrelevant in practice. If +size_of::<T>() > 0, this will never panic.

Examples
-
let a = [1, 2, 3];
-assert!(!a.is_empty());
-

Returns the first element of the slice, or None if it is empty.

+
#![feature(slice_flatten)]
+
+fn add_5_to_all(slice: &mut [i32]) {
+    for i in slice {
+        *i += 5;
+    }
+}
+
+let mut array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
+add_5_to_all(array.flatten_mut());
+assert_eq!(array, [[6, 7, 8], [9, 10, 11], [12, 13, 14]]);
+
source

pub fn as_str(&self) -> &str

🔬This is a nightly-only experimental API. (ascii_char)

Views this slice of ASCII characters as a UTF-8 str.

+
source

pub fn as_bytes(&self) -> &[u8]

🔬This is a nightly-only experimental API. (ascii_char)

Views this slice of ASCII characters as a slice of u8 bytes.

+
source

pub fn sort_floats(&mut self)

🔬This is a nightly-only experimental API. (sort_floats)

Sorts the slice of floats.

+

This sort is in-place (i.e. does not allocate), O(n * log(n)) worst-case, and uses +the ordering defined by f32::total_cmp.

+
Current implementation
+

This uses the same sorting algorithm as sort_unstable_by.

Examples
-
let v = [10, 40, 30];
-assert_eq!(Some(&10), v.first());
+
#![feature(sort_floats)]
+let mut v = [2.6, -5e-8, f32::NAN, 8.29, f32::INFINITY, -1.0, 0.0, -f32::INFINITY, -0.0];
 
-let w: &[i32] = &[];
-assert_eq!(None, w.first());

-

Returns a mutable pointer to the first element of the slice, or None if it is empty.

+v.sort_floats(); +let sorted = [-f32::INFINITY, -1.0, -5e-8, -0.0, 0.0, 2.6, 8.29, f32::INFINITY, f32::NAN]; +assert_eq!(&v[..8], &sorted[..8]); +assert!(v[8].is_nan());
+
1.0.0 · source

pub fn len(&self) -> usize

Returns the number of elements in the slice.

Examples
-
let x = &mut [0, 1, 2];
-
-if let Some(first) = x.first_mut() {
-    *first = 5;
-}
-assert_eq!(x, &[5, 1, 2]);
-

Returns the first and all the rest of the elements of the slice, or None if it is empty.

+
let a = [1, 2, 3];
+assert_eq!(a.len(), 3);
+
1.0.0 · source

pub fn is_empty(&self) -> bool

Returns true if the slice has a length of 0.

Examples
-
let x = &[0, 1, 2];
-
-if let Some((first, elements)) = x.split_first() {
-    assert_eq!(first, &0);
-    assert_eq!(elements, &[1, 2]);
-}
-

Returns the first and all the rest of the elements of the slice, or None if it is empty.

+
let a = [1, 2, 3];
+assert!(!a.is_empty());
+
1.0.0 · source

pub fn first(&self) -> Option<&T>

Returns the first element of the slice, or None if it is empty.

Examples
-
let x = &mut [0, 1, 2];
+
let v = [10, 40, 30];
+assert_eq!(Some(&10), v.first());
 
-if let Some((first, elements)) = x.split_first_mut() {
-    *first = 3;
-    elements[0] = 4;
-    elements[1] = 5;
-}
-assert_eq!(x, &[3, 4, 5]);

-

Returns the last and all the rest of the elements of the slice, or None if it is empty.

+let w: &[i32] = &[]; +assert_eq!(None, w.first());
+
1.0.0 · source

pub fn first_mut(&mut self) -> Option<&mut T>

Returns a mutable pointer to the first element of the slice, or None if it is empty.

Examples
-
let x = &[0, 1, 2];
+
let x = &mut [0, 1, 2];
 
-if let Some((last, elements)) = x.split_last() {
-    assert_eq!(last, &2);
-    assert_eq!(elements, &[0, 1]);
-}

-

Returns the last and all the rest of the elements of the slice, or None if it is empty.

+if let Some(first) = x.first_mut() { + *first = 5; +} +assert_eq!(x, &[5, 1, 2]);
+
1.5.0 · source

pub fn split_first(&self) -> Option<(&T, &[T])>

Returns the first and all the rest of the elements of the slice, or None if it is empty.

Examples
-
let x = &mut [0, 1, 2];
+
let x = &[0, 1, 2];
 
-if let Some((last, elements)) = x.split_last_mut() {
-    *last = 3;
-    elements[0] = 4;
-    elements[1] = 5;
-}
-assert_eq!(x, &[4, 5, 3]);

-

Returns the last element of the slice, or None if it is empty.

+if let Some((first, elements)) = x.split_first() { + assert_eq!(first, &0); + assert_eq!(elements, &[1, 2]); +}
+
1.5.0 · source

pub fn split_first_mut(&mut self) -> Option<(&mut T, &mut [T])>

Returns the first and all the rest of the elements of the slice, or None if it is empty.

Examples
-
let v = [10, 40, 30];
-assert_eq!(Some(&30), v.last());
+
let x = &mut [0, 1, 2];
 
-let w: &[i32] = &[];
-assert_eq!(None, w.last());

-

Returns a mutable pointer to the last item in the slice.

-
Examples
-
let x = &mut [0, 1, 2];
-
-if let Some(last) = x.last_mut() {
-    *last = 10;
+if let Some((first, elements)) = x.split_first_mut() {
+    *first = 3;
+    elements[0] = 4;
+    elements[1] = 5;
 }
-assert_eq!(x, &[0, 1, 10]);
-

Returns a reference to an element or subslice depending on the type of +assert_eq!(x, &[3, 4, 5]);

+
1.5.0 · source

pub fn split_last(&self) -> Option<(&T, &[T])>

Returns the last and all the rest of the elements of the slice, or None if it is empty.

+
Examples
+
let x = &[0, 1, 2];
+
+if let Some((last, elements)) = x.split_last() {
+    assert_eq!(last, &2);
+    assert_eq!(elements, &[0, 1]);
+}
+
1.5.0 · source

pub fn split_last_mut(&mut self) -> Option<(&mut T, &mut [T])>

Returns the last and all the rest of the elements of the slice, or None if it is empty.

+
Examples
+
let x = &mut [0, 1, 2];
+
+if let Some((last, elements)) = x.split_last_mut() {
+    *last = 3;
+    elements[0] = 4;
+    elements[1] = 5;
+}
+assert_eq!(x, &[4, 5, 3]);
+
1.0.0 · source

pub fn last(&self) -> Option<&T>

Returns the last element of the slice, or None if it is empty.

+
Examples
+
let v = [10, 40, 30];
+assert_eq!(Some(&30), v.last());
+
+let w: &[i32] = &[];
+assert_eq!(None, w.last());
+
1.0.0 · source

pub fn last_mut(&mut self) -> Option<&mut T>

Returns a mutable pointer to the last item in the slice.

+
Examples
+
let x = &mut [0, 1, 2];
+
+if let Some(last) = x.last_mut() {
+    *last = 10;
+}
+assert_eq!(x, &[0, 1, 10]);
+
source

pub fn first_chunk<const N: usize>(&self) -> Option<&[T; N]>

🔬This is a nightly-only experimental API. (slice_first_last_chunk)

Returns the first N elements of the slice, or None if it has fewer than N elements.

+
Examples
+
#![feature(slice_first_last_chunk)]
+
+let u = [10, 40, 30];
+assert_eq!(Some(&[10, 40]), u.first_chunk::<2>());
+
+let v: &[i32] = &[10];
+assert_eq!(None, v.first_chunk::<2>());
+
+let w: &[i32] = &[];
+assert_eq!(Some(&[]), w.first_chunk::<0>());
+
source

pub fn first_chunk_mut<const N: usize>(&mut self) -> Option<&mut [T; N]>

🔬This is a nightly-only experimental API. (slice_first_last_chunk)

Returns a mutable reference to the first N elements of the slice, +or None if it has fewer than N elements.

+
Examples
+
#![feature(slice_first_last_chunk)]
+
+let x = &mut [0, 1, 2];
+
+if let Some(first) = x.first_chunk_mut::<2>() {
+    first[0] = 5;
+    first[1] = 4;
+}
+assert_eq!(x, &[5, 4, 2]);
+
source

pub fn split_first_chunk<const N: usize>(&self) -> Option<(&[T; N], &[T])>

🔬This is a nightly-only experimental API. (slice_first_last_chunk)

Returns the first N elements of the slice and the remainder, +or None if it has fewer than N elements.

+
Examples
+
#![feature(slice_first_last_chunk)]
+
+let x = &[0, 1, 2];
+
+if let Some((first, elements)) = x.split_first_chunk::<2>() {
+    assert_eq!(first, &[0, 1]);
+    assert_eq!(elements, &[2]);
+}
+
source

pub fn split_first_chunk_mut<const N: usize>( + &mut self +) -> Option<(&mut [T; N], &mut [T])>

🔬This is a nightly-only experimental API. (slice_first_last_chunk)

Returns a mutable reference to the first N elements of the slice and the remainder, +or None if it has fewer than N elements.

+
Examples
+
#![feature(slice_first_last_chunk)]
+
+let x = &mut [0, 1, 2];
+
+if let Some((first, elements)) = x.split_first_chunk_mut::<2>() {
+    first[0] = 3;
+    first[1] = 4;
+    elements[0] = 5;
+}
+assert_eq!(x, &[3, 4, 5]);
+
source

pub fn split_last_chunk<const N: usize>(&self) -> Option<(&[T; N], &[T])>

🔬This is a nightly-only experimental API. (slice_first_last_chunk)

Returns the last N elements of the slice and the remainder, +or None if it has fewer than N elements.

+
Examples
+
#![feature(slice_first_last_chunk)]
+
+let x = &[0, 1, 2];
+
+if let Some((last, elements)) = x.split_last_chunk::<2>() {
+    assert_eq!(last, &[1, 2]);
+    assert_eq!(elements, &[0]);
+}
+
source

pub fn split_last_chunk_mut<const N: usize>( + &mut self +) -> Option<(&mut [T; N], &mut [T])>

🔬This is a nightly-only experimental API. (slice_first_last_chunk)

Returns the last and all the rest of the elements of the slice, or None if it is empty.

+
Examples
+
#![feature(slice_first_last_chunk)]
+
+let x = &mut [0, 1, 2];
+
+if let Some((last, elements)) = x.split_last_chunk_mut::<2>() {
+    last[0] = 3;
+    last[1] = 4;
+    elements[0] = 5;
+}
+assert_eq!(x, &[5, 3, 4]);
+
source

pub fn last_chunk<const N: usize>(&self) -> Option<&[T; N]>

🔬This is a nightly-only experimental API. (slice_first_last_chunk)

Returns the last element of the slice, or None if it is empty.

+
Examples
+
#![feature(slice_first_last_chunk)]
+
+let u = [10, 40, 30];
+assert_eq!(Some(&[40, 30]), u.last_chunk::<2>());
+
+let v: &[i32] = &[10];
+assert_eq!(None, v.last_chunk::<2>());
+
+let w: &[i32] = &[];
+assert_eq!(Some(&[]), w.last_chunk::<0>());
+
source

pub fn last_chunk_mut<const N: usize>(&mut self) -> Option<&mut [T; N]>

🔬This is a nightly-only experimental API. (slice_first_last_chunk)

Returns a mutable pointer to the last item in the slice.

+
Examples
+
#![feature(slice_first_last_chunk)]
+
+let x = &mut [0, 1, 2];
+
+if let Some(last) = x.last_chunk_mut::<2>() {
+    last[0] = 10;
+    last[1] = 20;
+}
+assert_eq!(x, &[0, 10, 20]);
+
1.0.0 · source

pub fn get<I>(&self, index: I) -> Option<&<I as SliceIndex<[T]>>::Output>where + I: SliceIndex<[T]>,

Returns a reference to an element or subslice depending on the type of index.

  • If given a position, returns a reference to the element at that @@ -187,85 +366,97 @@ position or None if out of bounds.
  • If given a range, returns the subslice corresponding to that range, or None if out of bounds.
-
Examples
-
let v = [10, 40, 30];
-assert_eq!(Some(&40), v.get(1));
-assert_eq!(Some(&[10, 40][..]), v.get(0..2));
-assert_eq!(None, v.get(3));
-assert_eq!(None, v.get(0..4));
-

Returns a mutable reference to an element or subslice depending on the -type of index (see get) or None if the index is out of bounds.

-
Examples
-
let x = &mut [0, 1, 2];
+
Examples

+
let v = [10, 40, 30];
+assert_eq!(Some(&40), v.get(1));
+assert_eq!(Some(&[10, 40][..]), v.get(0..2));
+assert_eq!(None, v.get(3));
+assert_eq!(None, v.get(0..4));

+
1.0.0 · source

pub fn get_mut<I>( + &mut self, + index: I +) -> Option<&mut <I as SliceIndex<[T]>>::Output>where + I: SliceIndex<[T]>,

Returns a mutable reference to an element or subslice depending on the +type of index (see get) or None if the index is out of bounds.

+
Examples
+
let x = &mut [0, 1, 2];
 
-if let Some(elem) = x.get_mut(1) {
-    *elem = 42;
+if let Some(elem) = x.get_mut(1) {
+    *elem = 42;
 }
-assert_eq!(x, &[0, 42, 2]);
-

Returns a reference to an element or subslice, without doing bounds +assert_eq!(x, &[0, 42, 2]);

+
1.0.0 · source

pub unsafe fn get_unchecked<I>( + &self, + index: I +) -> &<I as SliceIndex<[T]>>::Outputwhere + I: SliceIndex<[T]>,

Returns a reference to an element or subslice, without doing bounds checking.

-

For a safe alternative see get.

-
Safety
-

Calling this method with an out-of-bounds index is undefined behavior -even if the resulting reference is not used.

-
Examples
-
let x = &[1, 2, 4];
-
-unsafe {
-    assert_eq!(x.get_unchecked(1), &2);
-}
-

Returns a mutable reference to an element or subslice, without doing -bounds checking.

-

For a safe alternative see get_mut.

+

For a safe alternative see get.

Safety

Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.

-
Examples
-
let x = &mut [1, 2, 4];
+
Examples

+
let x = &[1, 2, 4];
 
-unsafe {
-    let elem = x.get_unchecked_mut(1);
-    *elem = 13;
+unsafe {
+    assert_eq!(x.get_unchecked(1), &2);
+}

+
1.0.0 · source

pub unsafe fn get_unchecked_mut<I>( + &mut self, + index: I +) -> &mut <I as SliceIndex<[T]>>::Outputwhere + I: SliceIndex<[T]>,

Returns a mutable reference to an element or subslice, without doing +bounds checking.

+

For a safe alternative see get_mut.

+
Safety
+

Calling this method with an out-of-bounds index is undefined behavior +even if the resulting reference is not used.

+
Examples
+
let x = &mut [1, 2, 4];
+
+unsafe {
+    let elem = x.get_unchecked_mut(1);
+    *elem = 13;
 }
-assert_eq!(x, &[1, 13, 4]);
-

Returns a raw pointer to the slice’s buffer.

+assert_eq!(x, &[1, 13, 4]);
+
1.0.0 · source

pub fn as_ptr(&self) -> *const T

Returns a raw pointer to the slice’s buffer.

The caller must ensure that the slice outlives the pointer this function returns, or else it will end up pointing to garbage.

The caller must also ensure that the memory the pointer (non-transitively) points to is never written to (except inside an UnsafeCell) using this pointer or any pointer -derived from it. If you need to mutate the contents of the slice, use as_mut_ptr.

+derived from it. If you need to mutate the contents of the slice, use as_mut_ptr.

Modifying the container referenced by this slice may cause its buffer to be reallocated, which would also make any pointers to it invalid.

-
Examples
-
let x = &[1, 2, 4];
-let x_ptr = x.as_ptr();
+
Examples

+
let x = &[1, 2, 4];
+let x_ptr = x.as_ptr();
 
-unsafe {
-    for i in 0..x.len() {
-        assert_eq!(x.get_unchecked(i), &*x_ptr.add(i));
+unsafe {
+    for i in 0..x.len() {
+        assert_eq!(x.get_unchecked(i), &*x_ptr.add(i));
     }
 }

-

Returns an unsafe mutable pointer to the slice’s buffer.

+
1.0.0 · source

pub fn as_mut_ptr(&mut self) -> *mut T

Returns an unsafe mutable pointer to the slice’s buffer.

The caller must ensure that the slice outlives the pointer this function returns, or else it will end up pointing to garbage.

Modifying the container referenced by this slice may cause its buffer to be reallocated, which would also make any pointers to it invalid.

-
Examples
-
let x = &mut [1, 2, 4];
-let x_ptr = x.as_mut_ptr();
+
Examples

+
let x = &mut [1, 2, 4];
+let x_ptr = x.as_mut_ptr();
 
-unsafe {
-    for i in 0..x.len() {
-        *x_ptr.add(i) += 2;
+unsafe {
+    for i in 0..x.len() {
+        *x_ptr.add(i) += 2;
     }
 }
-assert_eq!(x, &[3, 4, 6]);

-

Returns the two raw pointers spanning the slice.

+assert_eq!(x, &[3, 4, 6]);
+
1.48.0 · source

pub fn as_ptr_range(&self) -> Range<*const T>

Returns the two raw pointers spanning the slice.

The returned range is half-open, which means that the end pointer points one past the last element of the slice. This way, an empty slice is represented by two equal pointers, and the difference between the two pointers represents the size of the slice.

-

See as_ptr for warnings on using these pointers. The end pointer +

See as_ptr for warnings on using these pointers. The end pointer requires extra caution, as it does not point to a valid element in the slice.

This function is useful for interacting with foreign interfaces which @@ -274,234 +465,185 @@ common in C++.

It can also be useful to check if a pointer to an element refers to an element of this slice:

-
let a = [1, 2, 3];
-let x = &a[1] as *const _;
-let y = &5 as *const _;
+
let a = [1, 2, 3];
+let x = &a[1] as *const _;
+let y = &5 as *const _;
 
-assert!(a.as_ptr_range().contains(&x));
-assert!(!a.as_ptr_range().contains(&y));

-

Returns the two unsafe mutable pointers spanning the slice.

+assert!(a.as_ptr_range().contains(&x)); +assert!(!a.as_ptr_range().contains(&y));
+
1.48.0 · source

pub fn as_mut_ptr_range(&mut self) -> Range<*mut T>

Returns the two unsafe mutable pointers spanning the slice.

The returned range is half-open, which means that the end pointer points one past the last element of the slice. This way, an empty slice is represented by two equal pointers, and the difference between the two pointers represents the size of the slice.

-

See as_mut_ptr for warnings on using these pointers. The end +

See as_mut_ptr for warnings on using these pointers. The end pointer requires extra caution, as it does not point to a valid element in the slice.

This function is useful for interacting with foreign interfaces which use two pointers to refer to a range of elements in memory, as is common in C++.

-

Swaps two elements in the slice.

+
1.0.0 · source

pub fn swap(&mut self, a: usize, b: usize)

Swaps two elements in the slice.

+

If a equals to b, it’s guaranteed that elements won’t change value.

Arguments
  • a - The index of the first element
  • b - The index of the second element
-
Panics
+
Panics

Panics if a or b are out of bounds.

-
Examples
-
let mut v = ["a", "b", "c", "d", "e"];
-v.swap(2, 4);
-assert!(v == ["a", "b", "e", "d", "c"]);
-
🔬 This is a nightly-only experimental API. (slice_swap_unchecked)

Swaps two elements in the slice, without doing bounds checking.

-

For a safe alternative see swap.

+
Examples
+
let mut v = ["a", "b", "c", "d", "e"];
+v.swap(2, 4);
+assert!(v == ["a", "b", "e", "d", "c"]);
+
source

pub unsafe fn swap_unchecked(&mut self, a: usize, b: usize)

🔬This is a nightly-only experimental API. (slice_swap_unchecked)

Swaps two elements in the slice, without doing bounds checking.

+

For a safe alternative see swap.

Arguments
  • a - The index of the first element
  • b - The index of the second element
-
Safety
+
Safety

Calling this method with an out-of-bounds index is undefined behavior. The caller has to ensure that a < self.len() and b < self.len().

-
Examples
-
#![feature(slice_swap_unchecked)]
+
Examples

+
#![feature(slice_swap_unchecked)]
 
-let mut v = ["a", "b", "c", "d"];
-// SAFETY: we know that 1 and 3 are both indices of the slice
-unsafe { v.swap_unchecked(1, 3) };
-assert!(v == ["a", "d", "c", "b"]);

-

Reverses the order of elements in the slice, in place.

-
Examples
-
let mut v = [1, 2, 3];
-v.reverse();
-assert!(v == [3, 2, 1]);
-

Returns an iterator over the slice.

+let mut v = ["a", "b", "c", "d"]; +// SAFETY: we know that 1 and 3 are both indices of the slice +unsafe { v.swap_unchecked(1, 3) }; +assert!(v == ["a", "d", "c", "b"]);
+
1.0.0 · source

pub fn reverse(&mut self)

Reverses the order of elements in the slice, in place.

+
Examples
+
let mut v = [1, 2, 3];
+v.reverse();
+assert!(v == [3, 2, 1]);
+
1.0.0 · source

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator over the slice.

The iterator yields all items from start to end.

-
Examples
-
let x = &[1, 2, 4];
-let mut iterator = x.iter();
+
Examples

+
let x = &[1, 2, 4];
+let mut iterator = x.iter();
 
-assert_eq!(iterator.next(), Some(&1));
-assert_eq!(iterator.next(), Some(&2));
-assert_eq!(iterator.next(), Some(&4));
-assert_eq!(iterator.next(), None);

-

Returns an iterator that allows modifying each value.

+assert_eq!(iterator.next(), Some(&1)); +assert_eq!(iterator.next(), Some(&2)); +assert_eq!(iterator.next(), Some(&4)); +assert_eq!(iterator.next(), None);
+
1.0.0 · source

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

The iterator yields all items from start to end.

-
Examples
-
let x = &mut [1, 2, 4];
-for elem in x.iter_mut() {
-    *elem += 2;
+
Examples

+
let x = &mut [1, 2, 4];
+for elem in x.iter_mut() {
+    *elem += 2;
 }
-assert_eq!(x, &[3, 4, 6]);

-

Returns an iterator over all contiguous windows of length +assert_eq!(x, &[3, 4, 6]);

+
1.0.0 · source

pub fn windows(&self, size: usize) -> Windows<'_, T>

Returns an iterator over all contiguous windows of length size. The windows overlap. If the slice is shorter than size, the iterator returns no values.

-
Panics
+
Panics

Panics if size is 0.

-
Examples
-
let slice = ['r', 'u', 's', 't'];
-let mut iter = slice.windows(2);
-assert_eq!(iter.next().unwrap(), &['r', 'u']);
-assert_eq!(iter.next().unwrap(), &['u', 's']);
-assert_eq!(iter.next().unwrap(), &['s', 't']);
-assert!(iter.next().is_none());
+
Examples
+
let slice = ['r', 'u', 's', 't'];
+let mut iter = slice.windows(2);
+assert_eq!(iter.next().unwrap(), &['r', 'u']);
+assert_eq!(iter.next().unwrap(), &['u', 's']);
+assert_eq!(iter.next().unwrap(), &['s', 't']);
+assert!(iter.next().is_none());

If the slice is shorter than size:

-
let slice = ['f', 'o', 'o'];
-let mut iter = slice.windows(4);
-assert!(iter.next().is_none());
-

Returns an iterator over chunk_size elements of the slice at a time, starting at the +

let slice = ['f', 'o', 'o'];
+let mut iter = slice.windows(4);
+assert!(iter.next().is_none());
+

There’s no windows_mut, as that existing would let safe code violate the +“only one &mut at a time to the same thing” rule. However, you can sometimes +use Cell::as_slice_of_cells in +conjunction with windows to accomplish something similar:

+ +
use std::cell::Cell;
+
+let mut array = ['R', 'u', 's', 't', ' ', '2', '0', '1', '5'];
+let slice = &mut array[..];
+let slice_of_cells: &[Cell<char>] = Cell::from_mut(slice).as_slice_of_cells();
+for w in slice_of_cells.windows(3) {
+    Cell::swap(&w[0], &w[2]);
+}
+assert_eq!(array, ['s', 't', ' ', '2', '0', '1', '5', 'u', 'R']);
+
1.0.0 · source

pub fn chunks(&self, chunk_size: usize) -> Chunks<'_, T>

Returns an iterator over chunk_size elements of the slice at a time, starting at the beginning of the slice.

The chunks are slices and do not overlap. If chunk_size does not divide the length of the slice, then the last chunk will not have length chunk_size.

-

See chunks_exact for a variant of this iterator that returns chunks of always exactly -chunk_size elements, and rchunks for the same iterator but starting at the end of the +

See chunks_exact for a variant of this iterator that returns chunks of always exactly +chunk_size elements, and rchunks for the same iterator but starting at the end of the slice.

-
Panics
+
Panics

Panics if chunk_size is 0.

-
Examples
-
let slice = ['l', 'o', 'r', 'e', 'm'];
-let mut iter = slice.chunks(2);
-assert_eq!(iter.next().unwrap(), &['l', 'o']);
-assert_eq!(iter.next().unwrap(), &['r', 'e']);
-assert_eq!(iter.next().unwrap(), &['m']);
-assert!(iter.next().is_none());
-

Returns an iterator over chunk_size elements of the slice at a time, starting at the +

Examples
+
let slice = ['l', 'o', 'r', 'e', 'm'];
+let mut iter = slice.chunks(2);
+assert_eq!(iter.next().unwrap(), &['l', 'o']);
+assert_eq!(iter.next().unwrap(), &['r', 'e']);
+assert_eq!(iter.next().unwrap(), &['m']);
+assert!(iter.next().is_none());
+
1.0.0 · source

pub fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<'_, T>

Returns an iterator over chunk_size elements of the slice at a time, starting at the beginning of the slice.

The chunks are mutable slices, and do not overlap. If chunk_size does not divide the length of the slice, then the last chunk will not have length chunk_size.

-

See chunks_exact_mut for a variant of this iterator that returns chunks of always -exactly chunk_size elements, and rchunks_mut for the same iterator but starting at +

See chunks_exact_mut for a variant of this iterator that returns chunks of always +exactly chunk_size elements, and rchunks_mut for the same iterator but starting at the end of the slice.

-
Panics
+
Panics

Panics if chunk_size is 0.

-
Examples
-
let v = &mut [0, 0, 0, 0, 0];
-let mut count = 1;
+
Examples

+
let v = &mut [0, 0, 0, 0, 0];
+let mut count = 1;
 
-for chunk in v.chunks_mut(2) {
-    for elem in chunk.iter_mut() {
-        *elem += count;
+for chunk in v.chunks_mut(2) {
+    for elem in chunk.iter_mut() {
+        *elem += count;
     }
-    count += 1;
+    count += 1;
 }
-assert_eq!(v, &[1, 1, 2, 2, 3]);

-

Returns an iterator over chunk_size elements of the slice at a time, starting at the +assert_eq!(v, &[1, 1, 2, 2, 3]);

+
1.31.0 · source

pub fn chunks_exact(&self, chunk_size: usize) -> ChunksExact<'_, T>

Returns an iterator over chunk_size elements of the slice at a time, starting at the beginning of the slice.

The chunks are slices and do not overlap. If chunk_size does not divide the length of the slice, then the last up to chunk_size-1 elements will be omitted and can be retrieved from the remainder function of the iterator.

Due to each chunk having exactly chunk_size elements, the compiler can often optimize the -resulting code better than in the case of chunks.

-

See chunks for a variant of this iterator that also returns the remainder as a smaller -chunk, and rchunks_exact for the same iterator but starting at the end of the slice.

-
Panics
+resulting code better than in the case of chunks.

+

See chunks for a variant of this iterator that also returns the remainder as a smaller +chunk, and rchunks_exact for the same iterator but starting at the end of the slice.

+
Panics

Panics if chunk_size is 0.

-
Examples
-
let slice = ['l', 'o', 'r', 'e', 'm'];
-let mut iter = slice.chunks_exact(2);
-assert_eq!(iter.next().unwrap(), &['l', 'o']);
-assert_eq!(iter.next().unwrap(), &['r', 'e']);
-assert!(iter.next().is_none());
-assert_eq!(iter.remainder(), &['m']);
-

Returns an iterator over chunk_size elements of the slice at a time, starting at the +

Examples
+
let slice = ['l', 'o', 'r', 'e', 'm'];
+let mut iter = slice.chunks_exact(2);
+assert_eq!(iter.next().unwrap(), &['l', 'o']);
+assert_eq!(iter.next().unwrap(), &['r', 'e']);
+assert!(iter.next().is_none());
+assert_eq!(iter.remainder(), &['m']);
+
1.31.0 · source

pub fn chunks_exact_mut(&mut self, chunk_size: usize) -> ChunksExactMut<'_, T>

Returns an iterator over chunk_size elements of the slice at a time, starting at the beginning of the slice.

The chunks are mutable slices, and do not overlap. If chunk_size does not divide the length of the slice, then the last up to chunk_size-1 elements will be omitted and can be retrieved from the into_remainder function of the iterator.

Due to each chunk having exactly chunk_size elements, the compiler can often optimize the -resulting code better than in the case of chunks_mut.

-

See chunks_mut for a variant of this iterator that also returns the remainder as a -smaller chunk, and rchunks_exact_mut for the same iterator but starting at the end of +resulting code better than in the case of chunks_mut.

+

See chunks_mut for a variant of this iterator that also returns the remainder as a +smaller chunk, and rchunks_exact_mut for the same iterator but starting at the end of the slice.

-
Panics
-

Panics if chunk_size is 0.

-
Examples
-
let v = &mut [0, 0, 0, 0, 0];
-let mut count = 1;
-
-for chunk in v.chunks_exact_mut(2) {
-    for elem in chunk.iter_mut() {
-        *elem += count;
-    }
-    count += 1;
-}
-assert_eq!(v, &[1, 1, 2, 2, 0]);
-
🔬 This is a nightly-only experimental API. (slice_as_chunks)

Splits the slice into a slice of N-element arrays, -assuming that there’s no remainder.

-
Safety
-

This may only be called when

-
    -
  • The slice splits exactly into N-element chunks (aka self.len() % N == 0).
    • -
  • N != 0.
    • -
-
Examples
-
#![feature(slice_as_chunks)]
-let slice: &[char] = &['l', 'o', 'r', 'e', 'm', '!'];
-let chunks: &[[char; 1]] =
-    // SAFETY: 1-element chunks never have remainder
-    unsafe { slice.as_chunks_unchecked() };
-assert_eq!(chunks, &[['l'], ['o'], ['r'], ['e'], ['m'], ['!']]);
-let chunks: &[[char; 3]] =
-    // SAFETY: The slice length (6) is a multiple of 3
-    unsafe { slice.as_chunks_unchecked() };
-assert_eq!(chunks, &[['l', 'o', 'r'], ['e', 'm', '!']]);
-
-// These would be unsound:
-// let chunks: &[[_; 5]] = slice.as_chunks_unchecked() // The slice length is not a multiple of 5
-// let chunks: &[[_; 0]] = slice.as_chunks_unchecked() // Zero-length chunks are never allowed
-
🔬 This is a nightly-only experimental API. (slice_as_chunks)

Splits the slice into a slice of N-element arrays, -starting at the beginning of the slice, -and a remainder slice with length strictly less than N.

-
Panics
-

Panics if N is 0. This check will most probably get changed to a compile time -error before this method gets stabilized.

-
Examples
-
#![feature(slice_as_chunks)]
-let slice = ['l', 'o', 'r', 'e', 'm'];
-let (chunks, remainder) = slice.as_chunks();
-assert_eq!(chunks, &[['l', 'o'], ['r', 'e']]);
-assert_eq!(remainder, &['m']);
-
🔬 This is a nightly-only experimental API. (slice_as_chunks)

Splits the slice into a slice of N-element arrays, -starting at the end of the slice, -and a remainder slice with length strictly less than N.

Panics
-

Panics if N is 0. This check will most probably get changed to a compile time -error before this method gets stabilized.

-
Examples
-
#![feature(slice_as_chunks)]
-let slice = ['l', 'o', 'r', 'e', 'm'];
-let (remainder, chunks) = slice.as_rchunks();
-assert_eq!(remainder, &['l']);
-assert_eq!(chunks, &[['o', 'r'], ['e', 'm']]);
-
🔬 This is a nightly-only experimental API. (array_chunks)

Returns an iterator over N elements of the slice at a time, starting at the -beginning of the slice.

-

The chunks are array references and do not overlap. If N does not divide the -length of the slice, then the last up to N-1 elements will be omitted and can be -retrieved from the remainder function of the iterator.

-

This method is the const generic equivalent of chunks_exact.

-
Panics
-

Panics if N is 0. This check will most probably get changed to a compile time -error before this method gets stabilized.

-
Examples
-
#![feature(array_chunks)]
-let slice = ['l', 'o', 'r', 'e', 'm'];
-let mut iter = slice.array_chunks();
-assert_eq!(iter.next().unwrap(), &['l', 'o']);
-assert_eq!(iter.next().unwrap(), &['r', 'e']);
-assert!(iter.next().is_none());
-assert_eq!(iter.remainder(), &['m']);
-
🔬 This is a nightly-only experimental API. (slice_as_chunks)

Splits the slice into a slice of N-element arrays, +

Panics if chunk_size is 0.

+
Examples
+
let v = &mut [0, 0, 0, 0, 0];
+let mut count = 1;
+
+for chunk in v.chunks_exact_mut(2) {
+    for elem in chunk.iter_mut() {
+        *elem += count;
+    }
+    count += 1;
+}
+assert_eq!(v, &[1, 1, 2, 2, 0]);
+
source

pub unsafe fn as_chunks_unchecked<const N: usize>(&self) -> &[[T; N]]

🔬This is a nightly-only experimental API. (slice_as_chunks)

Splits the slice into a slice of N-element arrays, assuming that there’s no remainder.

Safety

This may only be called when

@@ -509,751 +651,850 @@ assuming that there’s no remainder.

  • The slice splits exactly into N-element chunks (aka self.len() % N == 0).
  • N != 0.
    • -
    Examples
    -
    #![feature(slice_as_chunks)]
-let slice: &mut [char] = &mut ['l', 'o', 'r', 'e', 'm', '!'];
-let chunks: &mut [[char; 1]] =
-    // SAFETY: 1-element chunks never have remainder
-    unsafe { slice.as_chunks_unchecked_mut() };
-chunks[0] = ['L'];
-assert_eq!(chunks, &[['L'], ['o'], ['r'], ['e'], ['m'], ['!']]);
-let chunks: &mut [[char; 3]] =
-    // SAFETY: The slice length (6) is a multiple of 3
-    unsafe { slice.as_chunks_unchecked_mut() };
-chunks[1] = ['a', 'x', '?'];
-assert_eq!(slice, &['L', 'o', 'r', 'a', 'x', '?']);
+
    Examples
    
+
    #![feature(slice_as_chunks)]
+let slice: &[char] = &['l', 'o', 'r', 'e', 'm', '!'];
+let chunks: &[[char; 1]] =
+    // SAFETY: 1-element chunks never have remainder
+    unsafe { slice.as_chunks_unchecked() };
+assert_eq!(chunks, &[['l'], ['o'], ['r'], ['e'], ['m'], ['!']]);
+let chunks: &[[char; 3]] =
+    // SAFETY: The slice length (6) is a multiple of 3
+    unsafe { slice.as_chunks_unchecked() };
+assert_eq!(chunks, &[['l', 'o', 'r'], ['e', 'm', '!']]);
 
-// These would be unsound:
-// let chunks: &[[_; 5]] = slice.as_chunks_unchecked_mut() // The slice length is not a multiple of 5
-// let chunks: &[[_; 0]] = slice.as_chunks_unchecked_mut() // Zero-length chunks are never allowed
    
-
    🔬 This is a nightly-only experimental API. (slice_as_chunks)

    Splits the slice into a slice of N-element arrays, +// These would be unsound: +// let chunks: &[[_; 5]] = slice.as_chunks_unchecked() // The slice length is not a multiple of 5 +// let chunks: &[[_; 0]] = slice.as_chunks_unchecked() // Zero-length chunks are never allowed

    +
    source

    pub fn as_chunks<const N: usize>(&self) -> (&[[T; N]], &[T])

    🔬This is a nightly-only experimental API. (slice_as_chunks)

    Splits the slice into a slice of N-element arrays, starting at the beginning of the slice, and a remainder slice with length strictly less than N.

    +
    Panics
    +

    Panics if N is 0. This check will most probably get changed to a compile time +error before this method gets stabilized.

    +
    Examples
    +
    #![feature(slice_as_chunks)]
+let slice = ['l', 'o', 'r', 'e', 'm'];
+let (chunks, remainder) = slice.as_chunks();
+assert_eq!(chunks, &[['l', 'o'], ['r', 'e']]);
+assert_eq!(remainder, &['m']);
    +

    If you expect the slice to be an exact multiple, you can combine +let-else with an empty slice pattern:

    + +
    #![feature(slice_as_chunks)]
+let slice = ['R', 'u', 's', 't'];
+let (chunks, []) = slice.as_chunks::<2>() else {
+    panic!("slice didn't have even length")
+};
+assert_eq!(chunks, &[['R', 'u'], ['s', 't']]);
    +
    source

    pub fn as_rchunks<const N: usize>(&self) -> (&[T], &[[T; N]])

    🔬This is a nightly-only experimental API. (slice_as_chunks)

    Splits the slice into a slice of N-element arrays, +starting at the end of the slice, +and a remainder slice with length strictly less than N.

    Panics

    Panics if N is 0. This check will most probably get changed to a compile time error before this method gets stabilized.

    -
    Examples
    -
    #![feature(slice_as_chunks)]
-let v = &mut [0, 0, 0, 0, 0];
-let mut count = 1;
-
-let (chunks, remainder) = v.as_chunks_mut();
-remainder[0] = 9;
-for chunk in chunks {
-    *chunk = [count; 2];
-    count += 1;
-}
-assert_eq!(v, &[1, 1, 2, 2, 9]);
    -
    🔬 This is a nightly-only experimental API. (slice_as_chunks)

    Splits the slice into a slice of N-element arrays, -starting at the end of the slice, -and a remainder slice with length strictly less than N.

    +
    Examples
    +
    #![feature(slice_as_chunks)]
+let slice = ['l', 'o', 'r', 'e', 'm'];
+let (remainder, chunks) = slice.as_rchunks();
+assert_eq!(remainder, &['l']);
+assert_eq!(chunks, &[['o', 'r'], ['e', 'm']]);
    +
    source

    pub fn array_chunks<const N: usize>(&self) -> ArrayChunks<'_, T, N>

    🔬This is a nightly-only experimental API. (array_chunks)

    Returns an iterator over N elements of the slice at a time, starting at the +beginning of the slice.

    +

    The chunks are array references and do not overlap. If N does not divide the +length of the slice, then the last up to N-1 elements will be omitted and can be +retrieved from the remainder function of the iterator.

    +

    This method is the const generic equivalent of chunks_exact.

    Panics

    Panics if N is 0. This check will most probably get changed to a compile time error before this method gets stabilized.

    -
    Examples
    -
    #![feature(slice_as_chunks)]
-let v = &mut [0, 0, 0, 0, 0];
-let mut count = 1;
+
    Examples
    
+
    #![feature(array_chunks)]
+let slice = ['l', 'o', 'r', 'e', 'm'];
+let mut iter = slice.array_chunks();
+assert_eq!(iter.next().unwrap(), &['l', 'o']);
+assert_eq!(iter.next().unwrap(), &['r', 'e']);
+assert!(iter.next().is_none());
+assert_eq!(iter.remainder(), &['m']);
    
+
    source

    pub unsafe fn as_chunks_unchecked_mut<const N: usize>( + &mut self +) -> &mut [[T; N]]

    🔬This is a nightly-only experimental API. (slice_as_chunks)

    Splits the slice into a slice of N-element arrays, +assuming that there’s no remainder.

    +
    Safety
    +

    This may only be called when

    +
      +
    • The slice splits exactly into N-element chunks (aka self.len() % N == 0).
      • +
    • N != 0.
      • +
    +
    Examples
    +
    #![feature(slice_as_chunks)]
+let slice: &mut [char] = &mut ['l', 'o', 'r', 'e', 'm', '!'];
+let chunks: &mut [[char; 1]] =
+    // SAFETY: 1-element chunks never have remainder
+    unsafe { slice.as_chunks_unchecked_mut() };
+chunks[0] = ['L'];
+assert_eq!(chunks, &[['L'], ['o'], ['r'], ['e'], ['m'], ['!']]);
+let chunks: &mut [[char; 3]] =
+    // SAFETY: The slice length (6) is a multiple of 3
+    unsafe { slice.as_chunks_unchecked_mut() };
+chunks[1] = ['a', 'x', '?'];
+assert_eq!(slice, &['L', 'o', 'r', 'a', 'x', '?']);
 
-let (remainder, chunks) = v.as_rchunks_mut();
-remainder[0] = 9;
-for chunk in chunks {
-    *chunk = [count; 2];
-    count += 1;
+// These would be unsound:
+// let chunks: &[[_; 5]] = slice.as_chunks_unchecked_mut() // The slice length is not a multiple of 5
+// let chunks: &[[_; 0]] = slice.as_chunks_unchecked_mut() // Zero-length chunks are never allowed
    +
    source

    pub fn as_chunks_mut<const N: usize>(&mut self) -> (&mut [[T; N]], &mut [T])

    🔬This is a nightly-only experimental API. (slice_as_chunks)

    Splits the slice into a slice of N-element arrays, +starting at the beginning of the slice, +and a remainder slice with length strictly less than N.

    +
    Panics
    +

    Panics if N is 0. This check will most probably get changed to a compile time +error before this method gets stabilized.

    +
    Examples
    +
    #![feature(slice_as_chunks)]
+let v = &mut [0, 0, 0, 0, 0];
+let mut count = 1;
+
+let (chunks, remainder) = v.as_chunks_mut();
+remainder[0] = 9;
+for chunk in chunks {
+    *chunk = [count; 2];
+    count += 1;
 }
-assert_eq!(v, &[9, 1, 1, 2, 2]);
    -
    🔬 This is a nightly-only experimental API. (array_chunks)

    Returns an iterator over N elements of the slice at a time, starting at the +assert_eq!(v, &[1, 1, 2, 2, 9]);

    +
    source

    pub fn as_rchunks_mut<const N: usize>(&mut self) -> (&mut [T], &mut [[T; N]])

    🔬This is a nightly-only experimental API. (slice_as_chunks)

    Splits the slice into a slice of N-element arrays, +starting at the end of the slice, +and a remainder slice with length strictly less than N.

    +
    Panics
    +

    Panics if N is 0. This check will most probably get changed to a compile time +error before this method gets stabilized.

    +
    Examples
    +
    #![feature(slice_as_chunks)]
+let v = &mut [0, 0, 0, 0, 0];
+let mut count = 1;
+
+let (remainder, chunks) = v.as_rchunks_mut();
+remainder[0] = 9;
+for chunk in chunks {
+    *chunk = [count; 2];
+    count += 1;
+}
+assert_eq!(v, &[9, 1, 1, 2, 2]);
    +
    source

    pub fn array_chunks_mut<const N: usize>(&mut self) -> ArrayChunksMut<'_, T, N>

    🔬This is a nightly-only experimental API. (array_chunks)

    Returns an iterator over N elements of the slice at a time, starting at the beginning of the slice.

    The chunks are mutable array references and do not overlap. If N does not divide the length of the slice, then the last up to N-1 elements will be omitted and can be retrieved from the into_remainder function of the iterator.

    -

    This method is the const generic equivalent of chunks_exact_mut.

    -
    Panics
    +

    This method is the const generic equivalent of chunks_exact_mut.

    +
    Panics

    Panics if N is 0. This check will most probably get changed to a compile time error before this method gets stabilized.

    -
    Examples
    -
    #![feature(array_chunks)]
-let v = &mut [0, 0, 0, 0, 0];
-let mut count = 1;
+
    Examples
    
+
    #![feature(array_chunks)]
+let v = &mut [0, 0, 0, 0, 0];
+let mut count = 1;
 
-for chunk in v.array_chunks_mut() {
-    *chunk = [count; 2];
-    count += 1;
+for chunk in v.array_chunks_mut() {
+    *chunk = [count; 2];
+    count += 1;
 }
-assert_eq!(v, &[1, 1, 2, 2, 0]);
    
-
    🔬 This is a nightly-only experimental API. (array_windows)

    Returns an iterator over overlapping windows of N elements of a slice, +assert_eq!(v, &[1, 1, 2, 2, 0]);

    +
    source

    pub fn array_windows<const N: usize>(&self) -> ArrayWindows<'_, T, N>

    🔬This is a nightly-only experimental API. (array_windows)

    Returns an iterator over overlapping windows of N elements of a slice, starting at the beginning of the slice.

    -

    This is the const generic equivalent of windows.

    +

    This is the const generic equivalent of windows.

    If N is greater than the size of the slice, it will return no windows.

    -
    Panics
    +
    Panics

    Panics if N is 0. This check will most probably get changed to a compile time error before this method gets stabilized.

    -
    Examples
    -
    #![feature(array_windows)]
-let slice = [0, 1, 2, 3];
-let mut iter = slice.array_windows();
-assert_eq!(iter.next().unwrap(), &[0, 1]);
-assert_eq!(iter.next().unwrap(), &[1, 2]);
-assert_eq!(iter.next().unwrap(), &[2, 3]);
-assert!(iter.next().is_none());
    -

    Returns an iterator over chunk_size elements of the slice at a time, starting at the end +

    Examples
    +
    #![feature(array_windows)]
+let slice = [0, 1, 2, 3];
+let mut iter = slice.array_windows();
+assert_eq!(iter.next().unwrap(), &[0, 1]);
+assert_eq!(iter.next().unwrap(), &[1, 2]);
+assert_eq!(iter.next().unwrap(), &[2, 3]);
+assert!(iter.next().is_none());
    +
    1.31.0 · source

    pub fn rchunks(&self, chunk_size: usize) -> RChunks<'_, T>

    Returns an iterator over chunk_size elements of the slice at a time, starting at the end of the slice.

    The chunks are slices and do not overlap. If chunk_size does not divide the length of the slice, then the last chunk will not have length chunk_size.

    -

    See rchunks_exact for a variant of this iterator that returns chunks of always exactly -chunk_size elements, and chunks for the same iterator but starting at the beginning +

    See rchunks_exact for a variant of this iterator that returns chunks of always exactly +chunk_size elements, and chunks for the same iterator but starting at the beginning of the slice.

    -
    Panics
    +
    Panics

    Panics if chunk_size is 0.

    -
    Examples
    -
    let slice = ['l', 'o', 'r', 'e', 'm'];
-let mut iter = slice.rchunks(2);
-assert_eq!(iter.next().unwrap(), &['e', 'm']);
-assert_eq!(iter.next().unwrap(), &['o', 'r']);
-assert_eq!(iter.next().unwrap(), &['l']);
-assert!(iter.next().is_none());
    -

    Returns an iterator over chunk_size elements of the slice at a time, starting at the end +

    Examples
    +
    let slice = ['l', 'o', 'r', 'e', 'm'];
+let mut iter = slice.rchunks(2);
+assert_eq!(iter.next().unwrap(), &['e', 'm']);
+assert_eq!(iter.next().unwrap(), &['o', 'r']);
+assert_eq!(iter.next().unwrap(), &['l']);
+assert!(iter.next().is_none());
    +
    1.31.0 · source

    pub fn rchunks_mut(&mut self, chunk_size: usize) -> RChunksMut<'_, T>

    Returns an iterator over chunk_size elements of the slice at a time, starting at the end of the slice.

    The chunks are mutable slices, and do not overlap. If chunk_size does not divide the length of the slice, then the last chunk will not have length chunk_size.

    -

    See rchunks_exact_mut for a variant of this iterator that returns chunks of always -exactly chunk_size elements, and chunks_mut for the same iterator but starting at the +

    See rchunks_exact_mut for a variant of this iterator that returns chunks of always +exactly chunk_size elements, and chunks_mut for the same iterator but starting at the beginning of the slice.

    -
    Panics
    +
    Panics

    Panics if chunk_size is 0.

    -
    Examples
    -
    let v = &mut [0, 0, 0, 0, 0];
-let mut count = 1;
+
    Examples
    
+
    let v = &mut [0, 0, 0, 0, 0];
+let mut count = 1;
 
-for chunk in v.rchunks_mut(2) {
-    for elem in chunk.iter_mut() {
-        *elem += count;
+for chunk in v.rchunks_mut(2) {
+    for elem in chunk.iter_mut() {
+        *elem += count;
     }
-    count += 1;
+    count += 1;
 }
-assert_eq!(v, &[3, 2, 2, 1, 1]);
    
-

    Returns an iterator over chunk_size elements of the slice at a time, starting at the +assert_eq!(v, &[3, 2, 2, 1, 1]);

    +
    1.31.0 · source

    pub fn rchunks_exact(&self, chunk_size: usize) -> RChunksExact<'_, T>

    Returns an iterator over chunk_size elements of the slice at a time, starting at the end of the slice.

    The chunks are slices and do not overlap. If chunk_size does not divide the length of the slice, then the last up to chunk_size-1 elements will be omitted and can be retrieved from the remainder function of the iterator.

    Due to each chunk having exactly chunk_size elements, the compiler can often optimize the -resulting code better than in the case of rchunks.

    -

    See rchunks for a variant of this iterator that also returns the remainder as a smaller -chunk, and chunks_exact for the same iterator but starting at the beginning of the +resulting code better than in the case of rchunks.

    +

    See rchunks for a variant of this iterator that also returns the remainder as a smaller +chunk, and chunks_exact for the same iterator but starting at the beginning of the slice.

    -
    Panics
    +
    Panics

    Panics if chunk_size is 0.

    -
    Examples
    -
    let slice = ['l', 'o', 'r', 'e', 'm'];
-let mut iter = slice.rchunks_exact(2);
-assert_eq!(iter.next().unwrap(), &['e', 'm']);
-assert_eq!(iter.next().unwrap(), &['o', 'r']);
-assert!(iter.next().is_none());
-assert_eq!(iter.remainder(), &['l']);
    -

    Returns an iterator over chunk_size elements of the slice at a time, starting at the end +

    Examples
    +
    let slice = ['l', 'o', 'r', 'e', 'm'];
+let mut iter = slice.rchunks_exact(2);
+assert_eq!(iter.next().unwrap(), &['e', 'm']);
+assert_eq!(iter.next().unwrap(), &['o', 'r']);
+assert!(iter.next().is_none());
+assert_eq!(iter.remainder(), &['l']);
    +
    1.31.0 · source

    pub fn rchunks_exact_mut(&mut self, chunk_size: usize) -> RChunksExactMut<'_, T>

    Returns an iterator over chunk_size elements of the slice at a time, starting at the end of the slice.

    The chunks are mutable slices, and do not overlap. If chunk_size does not divide the length of the slice, then the last up to chunk_size-1 elements will be omitted and can be retrieved from the into_remainder function of the iterator.

    Due to each chunk having exactly chunk_size elements, the compiler can often optimize the -resulting code better than in the case of chunks_mut.

    -

    See rchunks_mut for a variant of this iterator that also returns the remainder as a -smaller chunk, and chunks_exact_mut for the same iterator but starting at the beginning +resulting code better than in the case of chunks_mut.

    +

    See rchunks_mut for a variant of this iterator that also returns the remainder as a +smaller chunk, and chunks_exact_mut for the same iterator but starting at the beginning of the slice.

    -
    Panics
    +
    Panics

    Panics if chunk_size is 0.

    -
    Examples
    -
    let v = &mut [0, 0, 0, 0, 0];
-let mut count = 1;
+
    Examples
    
+
    let v = &mut [0, 0, 0, 0, 0];
+let mut count = 1;
 
-for chunk in v.rchunks_exact_mut(2) {
-    for elem in chunk.iter_mut() {
-        *elem += count;
+for chunk in v.rchunks_exact_mut(2) {
+    for elem in chunk.iter_mut() {
+        *elem += count;
     }
-    count += 1;
+    count += 1;
 }
-assert_eq!(v, &[0, 2, 2, 1, 1]);
    
-
    🔬 This is a nightly-only experimental API. (slice_group_by)

    Returns an iterator over the slice producing non-overlapping runs +assert_eq!(v, &[0, 2, 2, 1, 1]);

    +
    source

    pub fn group_by<F>(&self, pred: F) -> GroupBy<'_, T, F>where + F: FnMut(&T, &T) -> bool,

    🔬This is a nightly-only experimental API. (slice_group_by)

    Returns an iterator over the slice producing non-overlapping runs of elements using the predicate to separate them.

    The predicate is called on two elements following themselves, it means the predicate is called on slice[0] and slice[1] then on slice[1] and slice[2] and so on.

    -
    Examples
    -
    #![feature(slice_group_by)]
+
    Examples
    
+
    #![feature(slice_group_by)]
 
-let slice = &[1, 1, 1, 3, 3, 2, 2, 2];
+let slice = &[1, 1, 1, 3, 3, 2, 2, 2];
 
-let mut iter = slice.group_by(|a, b| a == b);
+let mut iter = slice.group_by(|a, b| a == b);
 
-assert_eq!(iter.next(), Some(&[1, 1, 1][..]));
-assert_eq!(iter.next(), Some(&[3, 3][..]));
-assert_eq!(iter.next(), Some(&[2, 2, 2][..]));
-assert_eq!(iter.next(), None);
    
+assert_eq!(iter.next(), Some(&[1, 1, 1][..]));
+assert_eq!(iter.next(), Some(&[3, 3][..]));
+assert_eq!(iter.next(), Some(&[2, 2, 2][..]));
+assert_eq!(iter.next(), None);

    This method can be used to extract the sorted subslices:

    -
    #![feature(slice_group_by)]
+
    #![feature(slice_group_by)]
 
-let slice = &[1, 1, 2, 3, 2, 3, 2, 3, 4];
+let slice = &[1, 1, 2, 3, 2, 3, 2, 3, 4];
 
-let mut iter = slice.group_by(|a, b| a <= b);
+let mut iter = slice.group_by(|a, b| a <= b);
 
-assert_eq!(iter.next(), Some(&[1, 1, 2, 3][..]));
-assert_eq!(iter.next(), Some(&[2, 3][..]));
-assert_eq!(iter.next(), Some(&[2, 3, 4][..]));
-assert_eq!(iter.next(), None);
    
-
    🔬 This is a nightly-only experimental API. (slice_group_by)

    Returns an iterator over the slice producing non-overlapping mutable +assert_eq!(iter.next(), Some(&[1, 1, 2, 3][..])); +assert_eq!(iter.next(), Some(&[2, 3][..])); +assert_eq!(iter.next(), Some(&[2, 3, 4][..])); +assert_eq!(iter.next(), None);

    +
    source

    pub fn group_by_mut<F>(&mut self, pred: F) -> GroupByMut<'_, T, F>where + F: FnMut(&T, &T) -> bool,

    🔬This is a nightly-only experimental API. (slice_group_by)

    Returns an iterator over the slice producing non-overlapping mutable runs of elements using the predicate to separate them.

    The predicate is called on two elements following themselves, it means the predicate is called on slice[0] and slice[1] then on slice[1] and slice[2] and so on.

    -
    Examples
    -
    #![feature(slice_group_by)]
+
    Examples
    
+
    #![feature(slice_group_by)]
 
-let slice = &mut [1, 1, 1, 3, 3, 2, 2, 2];
+let slice = &mut [1, 1, 1, 3, 3, 2, 2, 2];
 
-let mut iter = slice.group_by_mut(|a, b| a == b);
+let mut iter = slice.group_by_mut(|a, b| a == b);
 
-assert_eq!(iter.next(), Some(&mut [1, 1, 1][..]));
-assert_eq!(iter.next(), Some(&mut [3, 3][..]));
-assert_eq!(iter.next(), Some(&mut [2, 2, 2][..]));
-assert_eq!(iter.next(), None);
    
+assert_eq!(iter.next(), Some(&mut [1, 1, 1][..]));
+assert_eq!(iter.next(), Some(&mut [3, 3][..]));
+assert_eq!(iter.next(), Some(&mut [2, 2, 2][..]));
+assert_eq!(iter.next(), None);

    This method can be used to extract the sorted subslices:

    -
    #![feature(slice_group_by)]
+
    #![feature(slice_group_by)]
 
-let slice = &mut [1, 1, 2, 3, 2, 3, 2, 3, 4];
+let slice = &mut [1, 1, 2, 3, 2, 3, 2, 3, 4];
 
-let mut iter = slice.group_by_mut(|a, b| a <= b);
+let mut iter = slice.group_by_mut(|a, b| a <= b);
 
-assert_eq!(iter.next(), Some(&mut [1, 1, 2, 3][..]));
-assert_eq!(iter.next(), Some(&mut [2, 3][..]));
-assert_eq!(iter.next(), Some(&mut [2, 3, 4][..]));
-assert_eq!(iter.next(), None);
    
-

    Divides one slice into two at an index.

    +assert_eq!(iter.next(), Some(&mut [1, 1, 2, 3][..])); +assert_eq!(iter.next(), Some(&mut [2, 3][..])); +assert_eq!(iter.next(), Some(&mut [2, 3, 4][..])); +assert_eq!(iter.next(), None);
    +
    1.0.0 · source

    pub fn split_at(&self, mid: usize) -> (&[T], &[T])

    Divides one slice into two at an index.

    The first will contain all indices from [0, mid) (excluding the index mid itself) and the second will contain all indices from [mid, len) (excluding the index len itself).

    -
    Panics
    +
    Panics

    Panics if mid > len.

    -
    Examples
    -
    let v = [1, 2, 3, 4, 5, 6];
+
    Examples
    
+
    let v = [1, 2, 3, 4, 5, 6];
 
 {
-   let (left, right) = v.split_at(0);
-   assert_eq!(left, []);
-   assert_eq!(right, [1, 2, 3, 4, 5, 6]);
+   let (left, right) = v.split_at(0);
+   assert_eq!(left, []);
+   assert_eq!(right, [1, 2, 3, 4, 5, 6]);
 }
 
 {
-    let (left, right) = v.split_at(2);
-    assert_eq!(left, [1, 2]);
-    assert_eq!(right, [3, 4, 5, 6]);
+    let (left, right) = v.split_at(2);
+    assert_eq!(left, [1, 2]);
+    assert_eq!(right, [3, 4, 5, 6]);
 }
 
 {
-    let (left, right) = v.split_at(6);
-    assert_eq!(left, [1, 2, 3, 4, 5, 6]);
-    assert_eq!(right, []);
+    let (left, right) = v.split_at(6);
+    assert_eq!(left, [1, 2, 3, 4, 5, 6]);
+    assert_eq!(right, []);
 }
    
-

    Divides one mutable slice into two at an index.

    +
    1.0.0 · source

    pub fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T])

    Divides one mutable slice into two at an index.

    The first will contain all indices from [0, mid) (excluding the index mid itself) and the second will contain all indices from [mid, len) (excluding the index len itself).

    -
    Panics
    +
    Panics

    Panics if mid > len.

    -
    Examples
    -
    let mut v = [1, 0, 3, 0, 5, 6];
-let (left, right) = v.split_at_mut(2);
-assert_eq!(left, [1, 0]);
-assert_eq!(right, [3, 0, 5, 6]);
-left[1] = 2;
-right[1] = 4;
-assert_eq!(v, [1, 2, 3, 4, 5, 6]);
    -
    🔬 This is a nightly-only experimental API. (slice_split_at_unchecked)

    Divides one slice into two at an index, without doing bounds checking.

    +
    Examples
    +
    let mut v = [1, 0, 3, 0, 5, 6];
+let (left, right) = v.split_at_mut(2);
+assert_eq!(left, [1, 0]);
+assert_eq!(right, [3, 0, 5, 6]);
+left[1] = 2;
+right[1] = 4;
+assert_eq!(v, [1, 2, 3, 4, 5, 6]);
    +
    source

    pub unsafe fn split_at_unchecked(&self, mid: usize) -> (&[T], &[T])

    🔬This is a nightly-only experimental API. (slice_split_at_unchecked)

    Divides one slice into two at an index, without doing bounds checking.

    The first will contain all indices from [0, mid) (excluding the index mid itself) and the second will contain all indices from [mid, len) (excluding the index len itself).

    -

    For a safe alternative see split_at.

    -
    Safety
    -

    Calling this method with an out-of-bounds index is undefined behavior -even if the resulting reference is not used. The caller has to ensure that -0 <= mid <= self.len().

    -
    Examples
    -
    #![feature(slice_split_at_unchecked)]
-
-let v = [1, 2, 3, 4, 5, 6];
-
-unsafe {
-   let (left, right) = v.split_at_unchecked(0);
-   assert_eq!(left, []);
-   assert_eq!(right, [1, 2, 3, 4, 5, 6]);
-}
-
-unsafe {
-    let (left, right) = v.split_at_unchecked(2);
-    assert_eq!(left, [1, 2]);
-    assert_eq!(right, [3, 4, 5, 6]);
-}
-
-unsafe {
-    let (left, right) = v.split_at_unchecked(6);
-    assert_eq!(left, [1, 2, 3, 4, 5, 6]);
-    assert_eq!(right, []);
-}
    -
    🔬 This is a nightly-only experimental API. (slice_split_at_unchecked)

    Divides one mutable slice into two at an index, without doing bounds checking.

    -

    The first will contain all indices from [0, mid) (excluding -the index mid itself) and the second will contain all -indices from [mid, len) (excluding the index len itself).

    -

    For a safe alternative see split_at_mut.

    +

    For a safe alternative see split_at.

    Safety

    Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used. The caller has to ensure that 0 <= mid <= self.len().

    -
    Examples
    -
    #![feature(slice_split_at_unchecked)]
+
    Examples
    
+
    #![feature(slice_split_at_unchecked)]
 
-let mut v = [1, 0, 3, 0, 5, 6];
-// scoped to restrict the lifetime of the borrows
-unsafe {
-    let (left, right) = v.split_at_mut_unchecked(2);
-    assert_eq!(left, [1, 0]);
-    assert_eq!(right, [3, 0, 5, 6]);
-    left[1] = 2;
-    right[1] = 4;
-}
-assert_eq!(v, [1, 2, 3, 4, 5, 6]);
    
-
    🔬 This is a nightly-only experimental API. (split_array)

    Divides one slice into an array and a remainder slice at an index.

    -

    The array will contain all indices from [0, N) (excluding -the index N itself) and the slice will contain all -indices from [N, len) (excluding the index len itself).

    -
    Panics
    -

    Panics if N > len.

    -
    Examples
    -
    #![feature(split_array)]
+let v = [1, 2, 3, 4, 5, 6];
 
-let v = &[1, 2, 3, 4, 5, 6][..];
-
-{
-   let (left, right) = v.split_array_ref::<0>();
-   assert_eq!(left, &[]);
-   assert_eq!(right, [1, 2, 3, 4, 5, 6]);
+unsafe {
+   let (left, right) = v.split_at_unchecked(0);
+   assert_eq!(left, []);
+   assert_eq!(right, [1, 2, 3, 4, 5, 6]);
 }
 
-{
-    let (left, right) = v.split_array_ref::<2>();
-    assert_eq!(left, &[1, 2]);
-    assert_eq!(right, [3, 4, 5, 6]);
+unsafe {
+    let (left, right) = v.split_at_unchecked(2);
+    assert_eq!(left, [1, 2]);
+    assert_eq!(right, [3, 4, 5, 6]);
 }
 
-{
-    let (left, right) = v.split_array_ref::<6>();
-    assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
-    assert_eq!(right, []);
+unsafe {
+    let (left, right) = v.split_at_unchecked(6);
+    assert_eq!(left, [1, 2, 3, 4, 5, 6]);
+    assert_eq!(right, []);
 }
    -
    🔬 This is a nightly-only experimental API. (split_array)

    Divides one mutable slice into an array and a remainder slice at an index.

    +
    source

    pub unsafe fn split_at_mut_unchecked( + &mut self, + mid: usize +) -> (&mut [T], &mut [T])

    🔬This is a nightly-only experimental API. (slice_split_at_unchecked)

    Divides one mutable slice into two at an index, without doing bounds checking.

    +

    The first will contain all indices from [0, mid) (excluding +the index mid itself) and the second will contain all +indices from [mid, len) (excluding the index len itself).

    +

    For a safe alternative see split_at_mut.

    +
    Safety
    +

    Calling this method with an out-of-bounds index is undefined behavior +even if the resulting reference is not used. The caller has to ensure that +0 <= mid <= self.len().

    +
    Examples
    +
    #![feature(slice_split_at_unchecked)]
+
+let mut v = [1, 0, 3, 0, 5, 6];
+// scoped to restrict the lifetime of the borrows
+unsafe {
+    let (left, right) = v.split_at_mut_unchecked(2);
+    assert_eq!(left, [1, 0]);
+    assert_eq!(right, [3, 0, 5, 6]);
+    left[1] = 2;
+    right[1] = 4;
+}
+assert_eq!(v, [1, 2, 3, 4, 5, 6]);
    +
    source

    pub fn split_array_ref<const N: usize>(&self) -> (&[T; N], &[T])

    🔬This is a nightly-only experimental API. (split_array)

    Divides one slice into an array and a remainder slice at an index.

    The array will contain all indices from [0, N) (excluding the index N itself) and the slice will contain all indices from [N, len) (excluding the index len itself).

    -
    Panics
    +
    Panics

    Panics if N > len.

    -
    Examples
    -
    #![feature(split_array)]
+
    Examples
    
+
    #![feature(split_array)]
 
-let mut v = &mut [1, 0, 3, 0, 5, 6][..];
-let (left, right) = v.split_array_mut::<2>();
-assert_eq!(left, &mut [1, 0]);
-assert_eq!(right, [3, 0, 5, 6]);
-left[1] = 2;
-right[1] = 4;
-assert_eq!(v, [1, 2, 3, 4, 5, 6]);
    
-
    🔬 This is a nightly-only experimental API. (split_array)

    Divides one slice into an array and a remainder slice at an index from +let v = &[1, 2, 3, 4, 5, 6][..]; + +{ + let (left, right) = v.split_array_ref::<0>(); + assert_eq!(left, &[]); + assert_eq!(right, [1, 2, 3, 4, 5, 6]); +} + +{ + let (left, right) = v.split_array_ref::<2>(); + assert_eq!(left, &[1, 2]); + assert_eq!(right, [3, 4, 5, 6]); +} + +{ + let (left, right) = v.split_array_ref::<6>(); + assert_eq!(left, &[1, 2, 3, 4, 5, 6]); + assert_eq!(right, []); +}

    +
    source

    pub fn split_array_mut<const N: usize>(&mut self) -> (&mut [T; N], &mut [T])

    🔬This is a nightly-only experimental API. (split_array)

    Divides one mutable slice into an array and a remainder slice at an index.

    +

    The array will contain all indices from [0, N) (excluding +the index N itself) and the slice will contain all +indices from [N, len) (excluding the index len itself).

    +
    Panics
    +

    Panics if N > len.

    +
    Examples
    +
    #![feature(split_array)]
+
+let mut v = &mut [1, 0, 3, 0, 5, 6][..];
+let (left, right) = v.split_array_mut::<2>();
+assert_eq!(left, &mut [1, 0]);
+assert_eq!(right, [3, 0, 5, 6]);
+left[1] = 2;
+right[1] = 4;
+assert_eq!(v, [1, 2, 3, 4, 5, 6]);
    +
    source

    pub fn rsplit_array_ref<const N: usize>(&self) -> (&[T], &[T; N])

    🔬This is a nightly-only experimental API. (split_array)

    Divides one slice into an array and a remainder slice at an index from the end.

    The slice will contain all indices from [0, len - N) (excluding the index len - N itself) and the array will contain all indices from [len - N, len) (excluding the index len itself).

    -
    Panics
    +
    Panics

    Panics if N > len.

    -
    Examples
    -
    #![feature(split_array)]
+
    Examples
    
+
    #![feature(split_array)]
 
-let v = &[1, 2, 3, 4, 5, 6][..];
+let v = &[1, 2, 3, 4, 5, 6][..];
 
 {
-   let (left, right) = v.rsplit_array_ref::<0>();
-   assert_eq!(left, [1, 2, 3, 4, 5, 6]);
-   assert_eq!(right, &[]);
+   let (left, right) = v.rsplit_array_ref::<0>();
+   assert_eq!(left, [1, 2, 3, 4, 5, 6]);
+   assert_eq!(right, &[]);
 }
 
 {
-    let (left, right) = v.rsplit_array_ref::<2>();
-    assert_eq!(left, [1, 2, 3, 4]);
-    assert_eq!(right, &[5, 6]);
+    let (left, right) = v.rsplit_array_ref::<2>();
+    assert_eq!(left, [1, 2, 3, 4]);
+    assert_eq!(right, &[5, 6]);
 }
 
 {
-    let (left, right) = v.rsplit_array_ref::<6>();
-    assert_eq!(left, []);
-    assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
+    let (left, right) = v.rsplit_array_ref::<6>();
+    assert_eq!(left, []);
+    assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
 }
    
-
    🔬 This is a nightly-only experimental API. (split_array)

    Divides one mutable slice into an array and a remainder slice at an +

    source

    pub fn rsplit_array_mut<const N: usize>(&mut self) -> (&mut [T], &mut [T; N])

    🔬This is a nightly-only experimental API. (split_array)

    Divides one mutable slice into an array and a remainder slice at an index from the end.

    The slice will contain all indices from [0, len - N) (excluding the index N itself) and the array will contain all indices from [len - N, len) (excluding the index len itself).

    -
    Panics
    +
    Panics

    Panics if N > len.

    -
    Examples
    -
    #![feature(split_array)]
+
    Examples
    
+
    #![feature(split_array)]
 
-let mut v = &mut [1, 0, 3, 0, 5, 6][..];
-let (left, right) = v.rsplit_array_mut::<4>();
-assert_eq!(left, [1, 0]);
-assert_eq!(right, &mut [3, 0, 5, 6]);
-left[1] = 2;
-right[1] = 4;
-assert_eq!(v, [1, 2, 3, 4, 5, 6]);
    
-

    Returns an iterator over subslices separated by elements that match +let mut v = &mut [1, 0, 3, 0, 5, 6][..]; +let (left, right) = v.rsplit_array_mut::<4>(); +assert_eq!(left, [1, 0]); +assert_eq!(right, &mut [3, 0, 5, 6]); +left[1] = 2; +right[1] = 4; +assert_eq!(v, [1, 2, 3, 4, 5, 6]);

    +
    1.0.0 · source

    pub fn split<F>(&self, pred: F) -> Split<'_, T, F>where + F: FnMut(&T) -> bool,

    Returns an iterator over subslices separated by elements that match pred. The matched element is not contained in the subslices.

    -
    Examples
    -
    let slice = [10, 40, 33, 20];
-let mut iter = slice.split(|num| num % 3 == 0);
+
    Examples
    
+
    let slice = [10, 40, 33, 20];
+let mut iter = slice.split(|num| num % 3 == 0);
 
-assert_eq!(iter.next().unwrap(), &[10, 40]);
-assert_eq!(iter.next().unwrap(), &[20]);
-assert!(iter.next().is_none());
    
+assert_eq!(iter.next().unwrap(), &[10, 40]);
+assert_eq!(iter.next().unwrap(), &[20]);
+assert!(iter.next().is_none());

    If the first element is matched, an empty slice will be the first item returned by the iterator. Similarly, if the last element in the slice is matched, an empty slice will be the last item returned by the iterator:

    -
    let slice = [10, 40, 33];
-let mut iter = slice.split(|num| num % 3 == 0);
+
    let slice = [10, 40, 33];
+let mut iter = slice.split(|num| num % 3 == 0);
 
-assert_eq!(iter.next().unwrap(), &[10, 40]);
-assert_eq!(iter.next().unwrap(), &[]);
-assert!(iter.next().is_none());
    
+assert_eq!(iter.next().unwrap(), &[10, 40]);
+assert_eq!(iter.next().unwrap(), &[]);
+assert!(iter.next().is_none());

    If two matched elements are directly adjacent, an empty slice will be present between them:

    -
    let slice = [10, 6, 33, 20];
-let mut iter = slice.split(|num| num % 3 == 0);
+
    let slice = [10, 6, 33, 20];
+let mut iter = slice.split(|num| num % 3 == 0);
 
-assert_eq!(iter.next().unwrap(), &[10]);
-assert_eq!(iter.next().unwrap(), &[]);
-assert_eq!(iter.next().unwrap(), &[20]);
-assert!(iter.next().is_none());
    
-

    Returns an iterator over mutable subslices separated by elements that +assert_eq!(iter.next().unwrap(), &[10]); +assert_eq!(iter.next().unwrap(), &[]); +assert_eq!(iter.next().unwrap(), &[20]); +assert!(iter.next().is_none());

    +
    1.0.0 · source

    pub fn split_mut<F>(&mut self, pred: F) -> SplitMut<'_, T, F>where + F: FnMut(&T) -> bool,

    Returns an iterator over mutable subslices separated by elements that match pred. The matched element is not contained in the subslices.

    -
    Examples
    -
    let mut v = [10, 40, 30, 20, 60, 50];
+
    Examples
    
+
    let mut v = [10, 40, 30, 20, 60, 50];
 
-for group in v.split_mut(|num| *num % 3 == 0) {
-    group[0] = 1;
+for group in v.split_mut(|num| *num % 3 == 0) {
+    group[0] = 1;
 }
-assert_eq!(v, [1, 40, 30, 1, 60, 1]);
    
-

    Returns an iterator over subslices separated by elements that match +assert_eq!(v, [1, 40, 30, 1, 60, 1]);

    +
    1.51.0 · source

    pub fn split_inclusive<F>(&self, pred: F) -> SplitInclusive<'_, T, F>where + F: FnMut(&T) -> bool,

    Returns an iterator over subslices separated by elements that match pred. The matched element is contained in the end of the previous subslice as a terminator.

    -
    Examples
    -
    let slice = [10, 40, 33, 20];
-let mut iter = slice.split_inclusive(|num| num % 3 == 0);
+
    Examples
    
+
    let slice = [10, 40, 33, 20];
+let mut iter = slice.split_inclusive(|num| num % 3 == 0);
 
-assert_eq!(iter.next().unwrap(), &[10, 40, 33]);
-assert_eq!(iter.next().unwrap(), &[20]);
-assert!(iter.next().is_none());
    
+assert_eq!(iter.next().unwrap(), &[10, 40, 33]);
+assert_eq!(iter.next().unwrap(), &[20]);
+assert!(iter.next().is_none());

    If the last element of the slice is matched, that element will be considered the terminator of the preceding slice. That slice will be the last item returned by the iterator.

    -
    let slice = [3, 10, 40, 33];
-let mut iter = slice.split_inclusive(|num| num % 3 == 0);
+
    let slice = [3, 10, 40, 33];
+let mut iter = slice.split_inclusive(|num| num % 3 == 0);
 
-assert_eq!(iter.next().unwrap(), &[3]);
-assert_eq!(iter.next().unwrap(), &[10, 40, 33]);
-assert!(iter.next().is_none());
    
-

    Returns an iterator over mutable subslices separated by elements that +assert_eq!(iter.next().unwrap(), &[3]); +assert_eq!(iter.next().unwrap(), &[10, 40, 33]); +assert!(iter.next().is_none());

    +
    1.51.0 · source

    pub fn split_inclusive_mut<F>(&mut self, pred: F) -> SplitInclusiveMut<'_, T, F>where + F: FnMut(&T) -> bool,

    Returns an iterator over mutable subslices separated by elements that match pred. The matched element is contained in the previous subslice as a terminator.

    -
    Examples
    -
    let mut v = [10, 40, 30, 20, 60, 50];
+
    Examples
    
+
    let mut v = [10, 40, 30, 20, 60, 50];
 
-for group in v.split_inclusive_mut(|num| *num % 3 == 0) {
-    let terminator_idx = group.len()-1;
-    group[terminator_idx] = 1;
+for group in v.split_inclusive_mut(|num| *num % 3 == 0) {
+    let terminator_idx = group.len()-1;
+    group[terminator_idx] = 1;
 }
-assert_eq!(v, [10, 40, 1, 20, 1, 1]);
    
-

    Returns an iterator over subslices separated by elements that match +assert_eq!(v, [10, 40, 1, 20, 1, 1]);

    +
    1.27.0 · source

    pub fn rsplit<F>(&self, pred: F) -> RSplit<'_, T, F>where + F: FnMut(&T) -> bool,

    Returns an iterator over subslices separated by elements that match pred, starting at the end of the slice and working backwards. The matched element is not contained in the subslices.

    -
    Examples
    -
    let slice = [11, 22, 33, 0, 44, 55];
-let mut iter = slice.rsplit(|num| *num == 0);
+
    Examples
    
+
    let slice = [11, 22, 33, 0, 44, 55];
+let mut iter = slice.rsplit(|num| *num == 0);
 
-assert_eq!(iter.next().unwrap(), &[44, 55]);
-assert_eq!(iter.next().unwrap(), &[11, 22, 33]);
-assert_eq!(iter.next(), None);
    
+assert_eq!(iter.next().unwrap(), &[44, 55]);
+assert_eq!(iter.next().unwrap(), &[11, 22, 33]);
+assert_eq!(iter.next(), None);

    As with split(), if the first or last element is matched, an empty slice will be the first (or last) item returned by the iterator.

    -
    let v = &[0, 1, 1, 2, 3, 5, 8];
-let mut it = v.rsplit(|n| *n % 2 == 0);
-assert_eq!(it.next().unwrap(), &[]);
-assert_eq!(it.next().unwrap(), &[3, 5]);
-assert_eq!(it.next().unwrap(), &[1, 1]);
-assert_eq!(it.next().unwrap(), &[]);
-assert_eq!(it.next(), None);
    -

    Returns an iterator over mutable subslices separated by elements that +

    let v = &[0, 1, 1, 2, 3, 5, 8];
+let mut it = v.rsplit(|n| *n % 2 == 0);
+assert_eq!(it.next().unwrap(), &[]);
+assert_eq!(it.next().unwrap(), &[3, 5]);
+assert_eq!(it.next().unwrap(), &[1, 1]);
+assert_eq!(it.next().unwrap(), &[]);
+assert_eq!(it.next(), None);
    +
    1.27.0 · source

    pub fn rsplit_mut<F>(&mut self, pred: F) -> RSplitMut<'_, T, F>where + F: FnMut(&T) -> bool,

    Returns an iterator over mutable subslices separated by elements that match pred, starting at the end of the slice and working backwards. The matched element is not contained in the subslices.

    -
    Examples
    -
    let mut v = [100, 400, 300, 200, 600, 500];
+
    Examples
    
+
    let mut v = [100, 400, 300, 200, 600, 500];
 
-let mut count = 0;
-for group in v.rsplit_mut(|num| *num % 3 == 0) {
-    count += 1;
-    group[0] = count;
+let mut count = 0;
+for group in v.rsplit_mut(|num| *num % 3 == 0) {
+    count += 1;
+    group[0] = count;
 }
-assert_eq!(v, [3, 400, 300, 2, 600, 1]);
    
-

    Returns an iterator over subslices separated by elements that match +assert_eq!(v, [3, 400, 300, 2, 600, 1]);

    +
    1.0.0 · source

    pub fn splitn<F>(&self, n: usize, pred: F) -> SplitN<'_, T, F>where + F: FnMut(&T) -> bool,

    Returns an iterator over subslices separated by elements that match pred, limited to returning at most n items. The matched element is not contained in the subslices.

    The last element returned, if any, will contain the remainder of the slice.

    -
    Examples
    +
    Examples

    Print the slice split once by numbers divisible by 3 (i.e., [10, 40], [20, 60, 50]):

    -
    let v = [10, 40, 30, 20, 60, 50];
+
    let v = [10, 40, 30, 20, 60, 50];
 
-for group in v.splitn(2, |num| *num % 3 == 0) {
+for group in v.splitn(2, |num| *num % 3 == 0) {
     println!("{group:?}");
 }
    
-

    Returns an iterator over subslices separated by elements that match +

    1.0.0 · source

    pub fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<'_, T, F>where + F: FnMut(&T) -> bool,

    Returns an iterator over mutable subslices separated by elements that match pred, limited to returning at most n items. The matched element is not contained in the subslices.

    The last element returned, if any, will contain the remainder of the slice.

    -
    Examples
    -
    let mut v = [10, 40, 30, 20, 60, 50];
+
    Examples
    
+
    let mut v = [10, 40, 30, 20, 60, 50];
 
-for group in v.splitn_mut(2, |num| *num % 3 == 0) {
-    group[0] = 1;
+for group in v.splitn_mut(2, |num| *num % 3 == 0) {
+    group[0] = 1;
 }
-assert_eq!(v, [1, 40, 30, 1, 60, 50]);
    
-

    Returns an iterator over subslices separated by elements that match +assert_eq!(v, [1, 40, 30, 1, 60, 50]);

    +
    1.0.0 · source

    pub fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<'_, T, F>where + F: FnMut(&T) -> bool,

    Returns an iterator over subslices separated by elements that match pred limited to returning at most n items. This starts at the end of the slice and works backwards. The matched element is not contained in the subslices.

    The last element returned, if any, will contain the remainder of the slice.

    -
    Examples
    +
    Examples

    Print the slice split once, starting from the end, by numbers divisible by 3 (i.e., [50], [10, 40, 30, 20]):

    -
    let v = [10, 40, 30, 20, 60, 50];
+
    let v = [10, 40, 30, 20, 60, 50];
 
-for group in v.rsplitn(2, |num| *num % 3 == 0) {
+for group in v.rsplitn(2, |num| *num % 3 == 0) {
     println!("{group:?}");
 }
    
-

    Returns an iterator over subslices separated by elements that match +

    1.0.0 · source

    pub fn rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<'_, T, F>where + F: FnMut(&T) -> bool,

    Returns an iterator over subslices separated by elements that match pred limited to returning at most n items. This starts at the end of the slice and works backwards. The matched element is not contained in the subslices.

    The last element returned, if any, will contain the remainder of the slice.

    -
    Examples
    -
    let mut s = [10, 40, 30, 20, 60, 50];
+
    Examples
    
+
    let mut s = [10, 40, 30, 20, 60, 50];
 
-for group in s.rsplitn_mut(2, |num| *num % 3 == 0) {
-    group[0] = 1;
+for group in s.rsplitn_mut(2, |num| *num % 3 == 0) {
+    group[0] = 1;
 }
-assert_eq!(s, [1, 40, 30, 20, 60, 1]);
    
-

    Returns true if the slice contains an element with the given value.

    +assert_eq!(s, [1, 40, 30, 20, 60, 1]);
    +
    1.0.0 · source

    pub fn contains(&self, x: &T) -> boolwhere + T: PartialEq<T>,

    Returns true if the slice contains an element with the given value.

    This operation is O(n).

    -

    Note that if you have a sorted slice, binary_search may be faster.

    -
    Examples
    -
    let v = [10, 40, 30];
-assert!(v.contains(&30));
-assert!(!v.contains(&50));
    +

    Note that if you have a sorted slice, binary_search may be faster.

    +
    Examples
    +
    let v = [10, 40, 30];
+assert!(v.contains(&30));
+assert!(!v.contains(&50));

    If you do not have a &T, but some other value that you can compare with one (for example, String implements PartialEq<str>), you can use iter().any:

    -
    let v = [String::from("hello"), String::from("world")]; // slice of `String`
-assert!(v.iter().any(|e| e == "hello")); // search with `&str`
-assert!(!v.iter().any(|e| e == "hi"));
    -

    Returns true if needle is a prefix of the slice.

    -
    Examples
    -
    let v = [10, 40, 30];
-assert!(v.starts_with(&[10]));
-assert!(v.starts_with(&[10, 40]));
-assert!(!v.starts_with(&[50]));
-assert!(!v.starts_with(&[10, 50]));
    +
    let v = [String::from("hello"), String::from("world")]; // slice of `String`
+assert!(v.iter().any(|e| e == "hello")); // search with `&str`
+assert!(!v.iter().any(|e| e == "hi"));
    +
    1.0.0 · source

    pub fn starts_with(&self, needle: &[T]) -> boolwhere + T: PartialEq<T>,

    Returns true if needle is a prefix of the slice.

    +
    Examples
    +
    let v = [10, 40, 30];
+assert!(v.starts_with(&[10]));
+assert!(v.starts_with(&[10, 40]));
+assert!(!v.starts_with(&[50]));
+assert!(!v.starts_with(&[10, 50]));

    Always returns true if needle is an empty slice:

    -
    let v = &[10, 40, 30];
-assert!(v.starts_with(&[]));
-let v: &[u8] = &[];
-assert!(v.starts_with(&[]));
    -

    Returns true if needle is a suffix of the slice.

    -
    Examples
    -
    let v = [10, 40, 30];
-assert!(v.ends_with(&[30]));
-assert!(v.ends_with(&[40, 30]));
-assert!(!v.ends_with(&[50]));
-assert!(!v.ends_with(&[50, 30]));
    +
    let v = &[10, 40, 30];
+assert!(v.starts_with(&[]));
+let v: &[u8] = &[];
+assert!(v.starts_with(&[]));
    +
    1.0.0 · source

    pub fn ends_with(&self, needle: &[T]) -> boolwhere + T: PartialEq<T>,

    Returns true if needle is a suffix of the slice.

    +
    Examples
    +
    let v = [10, 40, 30];
+assert!(v.ends_with(&[30]));
+assert!(v.ends_with(&[40, 30]));
+assert!(!v.ends_with(&[50]));
+assert!(!v.ends_with(&[50, 30]));

    Always returns true if needle is an empty slice:

    -
    let v = &[10, 40, 30];
-assert!(v.ends_with(&[]));
-let v: &[u8] = &[];
-assert!(v.ends_with(&[]));
    -

    Returns a subslice with the prefix removed.

    +
    let v = &[10, 40, 30];
+assert!(v.ends_with(&[]));
+let v: &[u8] = &[];
+assert!(v.ends_with(&[]));
    +
    1.51.0 · source

    pub fn strip_prefix<P>(&self, prefix: &P) -> Option<&[T]>where + P: SlicePattern<Item = T> + ?Sized, + T: PartialEq<T>,

    Returns a subslice with the prefix removed.

    If the slice starts with prefix, returns the subslice after the prefix, wrapped in Some. If prefix is empty, simply returns the original slice.

    If the slice does not start with prefix, returns None.

    -
    Examples
    -
    let v = &[10, 40, 30];
-assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));
-assert_eq!(v.strip_prefix(&[10, 40]), Some(&[30][..]));
-assert_eq!(v.strip_prefix(&[50]), None);
-assert_eq!(v.strip_prefix(&[10, 50]), None);
+
    Examples
    
+
    let v = &[10, 40, 30];
+assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));
+assert_eq!(v.strip_prefix(&[10, 40]), Some(&[30][..]));
+assert_eq!(v.strip_prefix(&[50]), None);
+assert_eq!(v.strip_prefix(&[10, 50]), None);
 
-let prefix : &str = "he";
-assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),
-           Some(b"llo".as_ref()));
    
-

    Returns a subslice with the suffix removed.

    +let prefix : &str = "he"; +assert_eq!(b"hello".strip_prefix(prefix.as_bytes()), + Some(b"llo".as_ref()));
    +
    1.51.0 · source

    pub fn strip_suffix<P>(&self, suffix: &P) -> Option<&[T]>where + P: SlicePattern<Item = T> + ?Sized, + T: PartialEq<T>,

    Returns a subslice with the suffix removed.

    If the slice ends with suffix, returns the subslice before the suffix, wrapped in Some. If suffix is empty, simply returns the original slice.

    If the slice does not end with suffix, returns None.

    -
    Examples
    -
    let v = &[10, 40, 30];
-assert_eq!(v.strip_suffix(&[30]), Some(&[10, 40][..]));
-assert_eq!(v.strip_suffix(&[40, 30]), Some(&[10][..]));
-assert_eq!(v.strip_suffix(&[50]), None);
-assert_eq!(v.strip_suffix(&[50, 30]), None);
    -

    Binary searches this slice for a given element. -This behaves similary to contains if this slice is sorted.

    -

    If the value is found then Result::Ok is returned, containing the +

    Examples
    +
    let v = &[10, 40, 30];
+assert_eq!(v.strip_suffix(&[30]), Some(&[10, 40][..]));
+assert_eq!(v.strip_suffix(&[40, 30]), Some(&[10][..]));
+assert_eq!(v.strip_suffix(&[50]), None);
+assert_eq!(v.strip_suffix(&[50, 30]), None);
    +

    Binary searches this slice for a given element. +If the slice is not sorted, the returned result is unspecified and +meaningless.

    +

    If the value is found then Result::Ok is returned, containing the index of the matching element. If there are multiple matches, then any one of the matches could be returned. The index is chosen deterministically, but is subject to change in future versions of Rust. -If the value is not found then Result::Err is returned, containing +If the value is not found then Result::Err is returned, containing the index where a matching element could be inserted while maintaining sorted order.

    -

    See also binary_search_by, binary_search_by_key, and partition_point.

    -
    Examples
    +

    See also binary_search_by, binary_search_by_key, and partition_point.

    +
    Examples

    Looks up a series of four elements. The first is found, with a uniquely determined position; the second and third are not found; the fourth could match any position in [1, 4].

    -
    let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
+
    let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
 
-assert_eq!(s.binary_search(&13),  Ok(9));
-assert_eq!(s.binary_search(&4),   Err(7));
-assert_eq!(s.binary_search(&100), Err(13));
-let r = s.binary_search(&1);
-assert!(match r { Ok(1..=4) => true, _ => false, });
    
+assert_eq!(s.binary_search(&13),  Ok(9));
+assert_eq!(s.binary_search(&4),   Err(7));
+assert_eq!(s.binary_search(&100), Err(13));
+let r = s.binary_search(&1);
+assert!(match r { Ok(1..=4) => true, _ => false, });
    +

    If you want to find that whole range of matching items, rather than +an arbitrary matching one, that can be done using partition_point:

    + +
    let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
+
+let low = s.partition_point(|x| x < &1);
+assert_eq!(low, 1);
+let high = s.partition_point(|x| x <= &1);
+assert_eq!(high, 5);
+let r = s.binary_search(&1);
+assert!((low..high).contains(&r.unwrap()));
+
+assert!(s[..low].iter().all(|&x| x < 1));
+assert!(s[low..high].iter().all(|&x| x == 1));
+assert!(s[high..].iter().all(|&x| x > 1));
+
+// For something not found, the "range" of equal items is empty
+assert_eq!(s.partition_point(|x| x < &11), 9);
+assert_eq!(s.partition_point(|x| x <= &11), 9);
+assert_eq!(s.binary_search(&11), Err(9));

    If you want to insert an item to a sorted vector, while maintaining -sort order, consider using partition_point:

    +sort order, consider using partition_point:

    -
    let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
-let num = 42;
-let idx = s.partition_point(|&x| x < num);
-// The above is equivalent to `let idx = s.binary_search(&num).unwrap_or_else(|x| x);`
-s.insert(idx, num);
-assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
    -

    Binary searches this slice with a comparator function. -This behaves similarly to contains if this slice is sorted.

    -

    The comparator function should implement an order consistent -with the sort order of the underlying slice, returning an -order code that indicates whether its argument is Less, -Equal or Greater the desired target.

    -

    If the value is found then Result::Ok is returned, containing the +

    let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
+let num = 42;
+let idx = s.partition_point(|&x| x < num);
+// The above is equivalent to `let idx = s.binary_search(&num).unwrap_or_else(|x| x);`
+s.insert(idx, num);
+assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
    +
    1.0.0 · source

    pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>where + F: FnMut(&'a T) -> Ordering,

    Binary searches this slice with a comparator function.

    +

    The comparator function should return an order code that indicates +whether its argument is Less, Equal or Greater the desired +target. +If the slice is not sorted or if the comparator function does not +implement an order consistent with the sort order of the underlying +slice, the returned result is unspecified and meaningless.

    +

    If the value is found then Result::Ok is returned, containing the index of the matching element. If there are multiple matches, then any one of the matches could be returned. The index is chosen deterministically, but is subject to change in future versions of Rust. -If the value is not found then Result::Err is returned, containing +If the value is not found then Result::Err is returned, containing the index where a matching element could be inserted while maintaining sorted order.

    -

    See also binary_search, binary_search_by_key, and partition_point.

    -
    Examples
    +

    See also binary_search, binary_search_by_key, and partition_point.

    +
    Examples

    Looks up a series of four elements. The first is found, with a uniquely determined position; the second and third are not found; the fourth could match any position in [1, 4].

    -
    let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
+
    let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
 
-let seek = 13;
-assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Ok(9));
-let seek = 4;
-assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(7));
-let seek = 100;
-assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(13));
-let seek = 1;
-let r = s.binary_search_by(|probe| probe.cmp(&seek));
-assert!(match r { Ok(1..=4) => true, _ => false, });
    
-

    Binary searches this slice with a key extraction function. -This behaves similarly to contains if this slice is sorted.

    +let seek = 13; +assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Ok(9)); +let seek = 4; +assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(7)); +let seek = 100; +assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(13)); +let seek = 1; +let r = s.binary_search_by(|probe| probe.cmp(&seek)); +assert!(match r { Ok(1..=4) => true, _ => false, });
    +
    1.10.0 · source

    pub fn binary_search_by_key<'a, B, F>( + &'a self, + b: &B, + f: F +) -> Result<usize, usize>where + F: FnMut(&'a T) -> B, + B: Ord,

    Binary searches this slice with a key extraction function.

    Assumes that the slice is sorted by the key, for instance with -sort_by_key using the same key extraction function.

    -

    If the value is found then Result::Ok is returned, containing the +sort_by_key using the same key extraction function. +If the slice is not sorted by the key, the returned result is +unspecified and meaningless.

    +

    If the value is found then Result::Ok is returned, containing the index of the matching element. If there are multiple matches, then any one of the matches could be returned. The index is chosen deterministically, but is subject to change in future versions of Rust. -If the value is not found then Result::Err is returned, containing +If the value is not found then Result::Err is returned, containing the index where a matching element could be inserted while maintaining sorted order.

    -

    See also binary_search, binary_search_by, and partition_point.

    -
    Examples
    +

    See also binary_search, binary_search_by, and partition_point.

    +
    Examples

    Looks up a series of four elements in a slice of pairs sorted by their second elements. The first is found, with a uniquely determined position; the second and third are not found; the fourth could match any position in [1, 4].

    -
    let s = [(0, 0), (2, 1), (4, 1), (5, 1), (3, 1),
+
    let s = [(0, 0), (2, 1), (4, 1), (5, 1), (3, 1),
          (1, 2), (2, 3), (4, 5), (5, 8), (3, 13),
          (1, 21), (2, 34), (4, 55)];
 
-assert_eq!(s.binary_search_by_key(&13, |&(a, b)| b),  Ok(9));
-assert_eq!(s.binary_search_by_key(&4, |&(a, b)| b),   Err(7));
-assert_eq!(s.binary_search_by_key(&100, |&(a, b)| b), Err(13));
-let r = s.binary_search_by_key(&1, |&(a, b)| b);
-assert!(match r { Ok(1..=4) => true, _ => false, });
    
-

    Sorts the slice, but might not preserve the order of equal elements.

    +assert_eq!(s.binary_search_by_key(&13, |&(a, b)| b), Ok(9)); +assert_eq!(s.binary_search_by_key(&4, |&(a, b)| b), Err(7)); +assert_eq!(s.binary_search_by_key(&100, |&(a, b)| b), Err(13)); +let r = s.binary_search_by_key(&1, |&(a, b)| b); +assert!(match r { Ok(1..=4) => true, _ => false, });
    +
    1.20.0 · source

    pub fn sort_unstable(&mut self)where + T: Ord,

    Sorts the slice, but might not preserve the order of equal elements.

    This sort is unstable (i.e., may reorder equal elements), in-place (i.e., does not allocate), and O(n * log(n)) worst-case.

    -
    Current implementation
    -

    The current algorithm is based on pattern-defeating quicksort by Orson Peters, -which combines the fast average case of randomized quicksort with the fast worst case of -heapsort, while achieving linear time on slices with certain patterns. It uses some -randomization to avoid degenerate cases, but with a fixed seed to always provide -deterministic behavior.

    -

    It is typically faster than stable sorting, except in a few special cases, e.g., when the -slice consists of several concatenated sorted sequences.

    -
    Examples
    -
    let mut v = [-5, 4, 1, -3, 2];
-
-v.sort_unstable();
-assert!(v == [-5, -3, 1, 2, 4]);
    -

    Sorts the slice with a comparator function, but might not preserve the order of equal -elements.

    -

    This sort is unstable (i.e., may reorder equal elements), in-place -(i.e., does not allocate), and O(n * log(n)) worst-case.

    -

    The comparator function must define a total ordering for the elements in the slice. If -the ordering is not total, the order of the elements is unspecified. An order is a -total order if it is (for all a, b and c):

    -
      -
    • total and antisymmetric: exactly one of a < b, a == b or a > b is true, and
      • -
    • transitive, a < b and b < c implies a < c. The same must hold for both == and >.
      • -
    -

    For example, while f64 doesn’t implement Ord because NaN != NaN, we can use -partial_cmp as our sort function when we know the slice doesn’t contain a NaN.

    - -
    let mut floats = [5f64, 4.0, 1.0, 3.0, 2.0];
-floats.sort_unstable_by(|a, b| a.partial_cmp(b).unwrap());
-assert_eq!(floats, [1.0, 2.0, 3.0, 4.0, 5.0]);
    Current implementation

    The current algorithm is based on pattern-defeating quicksort by Orson Peters, which combines the fast average case of randomized quicksort with the fast worst case of @@ -1262,127 +1503,186 @@ randomization to avoid degenerate cases, but with a fixed seed to always provide deterministic behavior.

    It is typically faster than stable sorting, except in a few special cases, e.g., when the slice consists of several concatenated sorted sequences.

    -
    Examples
    -
    let mut v = [5, 4, 1, 3, 2];
-v.sort_unstable_by(|a, b| a.cmp(b));
-assert!(v == [1, 2, 3, 4, 5]);
+
    Examples
    
+
    let mut v = [-5, 4, 1, -3, 2];
 
-// reverse sorting
-v.sort_unstable_by(|a, b| b.cmp(a));
-assert!(v == [5, 4, 3, 2, 1]);
    
-

    Sorts the slice with a key extraction function, but might not preserve the order of equal +v.sort_unstable(); +assert!(v == [-5, -3, 1, 2, 4]);

    +
    1.20.0 · source

    pub fn sort_unstable_by<F>(&mut self, compare: F)where + F: FnMut(&T, &T) -> Ordering,

    Sorts the slice with a comparator function, but might not preserve the order of equal elements.

    This sort is unstable (i.e., may reorder equal elements), in-place -(i.e., does not allocate), and O(m * n * log(n)) worst-case, where the key function is -O(m).

    +(i.e., does not allocate), and O(n * log(n)) worst-case.

    +

    The comparator function must define a total ordering for the elements in the slice. If +the ordering is not total, the order of the elements is unspecified. An order is a +total order if it is (for all a, b and c):

    +
      +
    • total and antisymmetric: exactly one of a < b, a == b or a > b is true, and
      • +
    • transitive, a < b and b < c implies a < c. The same must hold for both == and >.
      • +
    +

    For example, while f64 doesn’t implement Ord because NaN != NaN, we can use +partial_cmp as our sort function when we know the slice doesn’t contain a NaN.

    + +
    let mut floats = [5f64, 4.0, 1.0, 3.0, 2.0];
+floats.sort_unstable_by(|a, b| a.partial_cmp(b).unwrap());
+assert_eq!(floats, [1.0, 2.0, 3.0, 4.0, 5.0]);
    Current implementation

    The current algorithm is based on pattern-defeating quicksort by Orson Peters, which combines the fast average case of randomized quicksort with the fast worst case of heapsort, while achieving linear time on slices with certain patterns. It uses some randomization to avoid degenerate cases, but with a fixed seed to always provide deterministic behavior.

    +

    It is typically faster than stable sorting, except in a few special cases, e.g., when the +slice consists of several concatenated sorted sequences.

    +
    Examples
    +
    let mut v = [5, 4, 1, 3, 2];
+v.sort_unstable_by(|a, b| a.cmp(b));
+assert!(v == [1, 2, 3, 4, 5]);
+
+// reverse sorting
+v.sort_unstable_by(|a, b| b.cmp(a));
+assert!(v == [5, 4, 3, 2, 1]);
    +
    1.20.0 · source

    pub fn sort_unstable_by_key<K, F>(&mut self, f: F)where + F: FnMut(&T) -> K, + K: Ord,

    Sorts the slice with a key extraction function, but might not preserve the order of equal +elements.

    +

    This sort is unstable (i.e., may reorder equal elements), in-place +(i.e., does not allocate), and O(m * n * log(n)) worst-case, where the key function is +O(m).

    +
    Current implementation
    +

    The current algorithm is based on pattern-defeating quicksort by Orson Peters, +which combines the fast average case of randomized quicksort with the fast worst case of +heapsort, while achieving linear time on slices with certain patterns. It uses some +randomization to avoid degenerate cases, but with a fixed seed to always provide +deterministic behavior.

    Due to its key calling strategy, sort_unstable_by_key is likely to be slower than sort_by_cached_key in cases where the key function is expensive.

    -
    Examples
    -
    let mut v = [-5i32, 4, 1, -3, 2];
+
    Examples
    
+
    let mut v = [-5i32, 4, 1, -3, 2];
 
-v.sort_unstable_by_key(|k| k.abs());
-assert!(v == [1, 2, -3, 4, -5]);
    
-

    Reorder the slice such that the element at index is at its final sorted position.

    +v.sort_unstable_by_key(|k| k.abs()); +assert!(v == [1, 2, -3, 4, -5]);
    +
    1.49.0 · source

    pub fn select_nth_unstable( + &mut self, + index: usize +) -> (&mut [T], &mut T, &mut [T])where + T: Ord,

    Reorder the slice such that the element at index is at its final sorted position.

    This reordering has the additional property that any value at position i < index will be less than or equal to any value at a position j > index. Additionally, this reordering is unstable (i.e. any number of equal elements may end up at position index), in-place -(i.e. does not allocate), and O(n) worst-case. This function is also/ known as “kth -element” in other libraries. It returns a triplet of the following values: all elements less -than the one at the given index, the value at the given index, and all elements greater than -the one at the given index.

    -
    Current implementation
    -

    The current algorithm is based on the quickselect portion of the same quicksort algorithm -used for sort_unstable.

    -
    Panics
    +(i.e. does not allocate), and runs in O(n) time. +This function is also known as “kth element” in other libraries.

    +

    It returns a triplet of the following from the reordered slice: +the subslice prior to index, the element at index, and the subslice after index; +accordingly, the values in those two subslices will respectively all be less-than-or-equal-to +and greater-than-or-equal-to the value of the element at index.

    +
    Current implementation
    +

    The current algorithm is an introselect implementation based on Pattern Defeating Quicksort, which is also +the basis for sort_unstable. The fallback algorithm is Median of Medians using Tukey’s Ninther for +pivot selection, which guarantees linear runtime for all inputs.

    +
    Panics

    Panics when index >= len(), meaning it always panics on empty slices.

    -
    Examples
    -
    let mut v = [-5i32, 4, 1, -3, 2];
+
    Examples
    
+
    let mut v = [-5i32, 4, 1, -3, 2];
 
-// Find the median
-v.select_nth_unstable(2);
+// Find the median
+v.select_nth_unstable(2);
 
-// We are only guaranteed the slice will be one of the following, based on the way we sort
-// about the specified index.
-assert!(v == [-3, -5, 1, 2, 4] ||
-        v == [-5, -3, 1, 2, 4] ||
-        v == [-3, -5, 1, 4, 2] ||
-        v == [-5, -3, 1, 4, 2]);
    
-

    Reorder the slice with a comparator function such that the element at index is at its +// We are only guaranteed the slice will be one of the following, based on the way we sort +// about the specified index. +assert!(v == [-3, -5, 1, 2, 4] || + v == [-5, -3, 1, 2, 4] || + v == [-3, -5, 1, 4, 2] || + v == [-5, -3, 1, 4, 2]);

    +
    1.49.0 · source

    pub fn select_nth_unstable_by<F>( + &mut self, + index: usize, + compare: F +) -> (&mut [T], &mut T, &mut [T])where + F: FnMut(&T, &T) -> Ordering,

    Reorder the slice with a comparator function such that the element at index is at its final sorted position.

    This reordering has the additional property that any value at position i < index will be less than or equal to any value at a position j > index using the comparator function. Additionally, this reordering is unstable (i.e. any number of equal elements may end up at -position index), in-place (i.e. does not allocate), and O(n) worst-case. This function -is also known as “kth element” in other libraries. It returns a triplet of the following -values: all elements less than the one at the given index, the value at the given index, -and all elements greater than the one at the given index, using the provided comparator -function.

    -
    Current implementation
    -

    The current algorithm is based on the quickselect portion of the same quicksort algorithm -used for sort_unstable.

    -
    Panics
    +position index), in-place (i.e. does not allocate), and runs in O(n) time. +This function is also known as “kth element” in other libraries.

    +

    It returns a triplet of the following from +the slice reordered according to the provided comparator function: the subslice prior to +index, the element at index, and the subslice after index; accordingly, the values in +those two subslices will respectively all be less-than-or-equal-to and greater-than-or-equal-to +the value of the element at index.

    +
    Current implementation
    +

    The current algorithm is an introselect implementation based on Pattern Defeating Quicksort, which is also +the basis for sort_unstable. The fallback algorithm is Median of Medians using Tukey’s Ninther for +pivot selection, which guarantees linear runtime for all inputs.

    +
    Panics

    Panics when index >= len(), meaning it always panics on empty slices.

    -
    Examples
    -
    let mut v = [-5i32, 4, 1, -3, 2];
+
    Examples
    
+
    let mut v = [-5i32, 4, 1, -3, 2];
 
-// Find the median as if the slice were sorted in descending order.
-v.select_nth_unstable_by(2, |a, b| b.cmp(a));
+// Find the median as if the slice were sorted in descending order.
+v.select_nth_unstable_by(2, |a, b| b.cmp(a));
 
-// We are only guaranteed the slice will be one of the following, based on the way we sort
-// about the specified index.
-assert!(v == [2, 4, 1, -5, -3] ||
-        v == [2, 4, 1, -3, -5] ||
-        v == [4, 2, 1, -5, -3] ||
-        v == [4, 2, 1, -3, -5]);
    
-

    Reorder the slice with a key extraction function such that the element at index is at its +// We are only guaranteed the slice will be one of the following, based on the way we sort +// about the specified index. +assert!(v == [2, 4, 1, -5, -3] || + v == [2, 4, 1, -3, -5] || + v == [4, 2, 1, -5, -3] || + v == [4, 2, 1, -3, -5]);

    +
    1.49.0 · source

    pub fn select_nth_unstable_by_key<K, F>( + &mut self, + index: usize, + f: F +) -> (&mut [T], &mut T, &mut [T])where + F: FnMut(&T) -> K, + K: Ord,

    Reorder the slice with a key extraction function such that the element at index is at its final sorted position.

    This reordering has the additional property that any value at position i < index will be less than or equal to any value at a position j > index using the key extraction function. Additionally, this reordering is unstable (i.e. any number of equal elements may end up at -position index), in-place (i.e. does not allocate), and O(n) worst-case. This function -is also known as “kth element” in other libraries. It returns a triplet of the following -values: all elements less than the one at the given index, the value at the given index, and -all elements greater than the one at the given index, using the provided key extraction -function.

    -
    Current implementation
    -

    The current algorithm is based on the quickselect portion of the same quicksort algorithm -used for sort_unstable.

    -
    Panics
    +position index), in-place (i.e. does not allocate), and runs in O(n) time. +This function is also known as “kth element” in other libraries.

    +

    It returns a triplet of the following from +the slice reordered according to the provided key extraction function: the subslice prior to +index, the element at index, and the subslice after index; accordingly, the values in +those two subslices will respectively all be less-than-or-equal-to and greater-than-or-equal-to +the value of the element at index.

    +
    Current implementation
    +

    The current algorithm is an introselect implementation based on Pattern Defeating Quicksort, which is also +the basis for sort_unstable. The fallback algorithm is Median of Medians using Tukey’s Ninther for +pivot selection, which guarantees linear runtime for all inputs.

    +
    Panics

    Panics when index >= len(), meaning it always panics on empty slices.

    -
    Examples
    -
    let mut v = [-5i32, 4, 1, -3, 2];
+
    Examples
    
+
    let mut v = [-5i32, 4, 1, -3, 2];
 
-// Return the median as if the array were sorted according to absolute value.
-v.select_nth_unstable_by_key(2, |a| a.abs());
+// Return the median as if the array were sorted according to absolute value.
+v.select_nth_unstable_by_key(2, |a| a.abs());
 
-// We are only guaranteed the slice will be one of the following, based on the way we sort
-// about the specified index.
-assert!(v == [1, 2, -3, 4, -5] ||
-        v == [1, 2, -3, -5, 4] ||
-        v == [2, 1, -3, 4, -5] ||
-        v == [2, 1, -3, -5, 4]);
    
-
    🔬 This is a nightly-only experimental API. (slice_partition_dedup)

    Moves all consecutive repeated elements to the end of the slice according to the -PartialEq trait implementation.

    +// We are only guaranteed the slice will be one of the following, based on the way we sort +// about the specified index. +assert!(v == [1, 2, -3, 4, -5] || + v == [1, 2, -3, -5, 4] || + v == [2, 1, -3, 4, -5] || + v == [2, 1, -3, -5, 4]);
    +
    source

    pub fn partition_dedup(&mut self) -> (&mut [T], &mut [T])where + T: PartialEq<T>,

    🔬This is a nightly-only experimental API. (slice_partition_dedup)

    Moves all consecutive repeated elements to the end of the slice according to the +PartialEq trait implementation.

    Returns two slices. The first contains no consecutive repeated elements. The second contains all the duplicates in no specified order.

    If the slice is sorted, the first returned slice contains no duplicates.

    -
    Examples
    -
    #![feature(slice_partition_dedup)]
+
    Examples
    
+
    #![feature(slice_partition_dedup)]
 
-let mut slice = [1, 2, 2, 3, 3, 2, 1, 1];
+let mut slice = [1, 2, 2, 3, 3, 2, 1, 1];
 
-let (dedup, duplicates) = slice.partition_dedup();
+let (dedup, duplicates) = slice.partition_dedup();
 
-assert_eq!(dedup, [1, 2, 3, 2, 1]);
-assert_eq!(duplicates, [2, 3, 1]);
    
-
    🔬 This is a nightly-only experimental API. (slice_partition_dedup)

    Moves all but the first of consecutive elements to the end of the slice satisfying +assert_eq!(dedup, [1, 2, 3, 2, 1]); +assert_eq!(duplicates, [2, 3, 1]);

    +
    source

    pub fn partition_dedup_by<F>(&mut self, same_bucket: F) -> (&mut [T], &mut [T])where + F: FnMut(&mut T, &mut T) -> bool,

    🔬This is a nightly-only experimental API. (slice_partition_dedup)

    Moves all but the first of consecutive elements to the end of the slice satisfying a given equality relation.

    Returns two slices. The first contains no consecutive repeated elements. The second contains all the duplicates in no specified order.

    @@ -1391,249 +1691,262 @@ must determine if the elements compare equal. The elements are passed in opposit from their order in the slice, so if same_bucket(a, b) returns true, a is moved at the end of the slice.

    If the slice is sorted, the first returned slice contains no duplicates.

    -
    Examples
    -
    #![feature(slice_partition_dedup)]
+
    Examples
    
+
    #![feature(slice_partition_dedup)]
 
-let mut slice = ["foo", "Foo", "BAZ", "Bar", "bar", "baz", "BAZ"];
+let mut slice = ["foo", "Foo", "BAZ", "Bar", "bar", "baz", "BAZ"];
 
-let (dedup, duplicates) = slice.partition_dedup_by(|a, b| a.eq_ignore_ascii_case(b));
+let (dedup, duplicates) = slice.partition_dedup_by(|a, b| a.eq_ignore_ascii_case(b));
 
-assert_eq!(dedup, ["foo", "BAZ", "Bar", "baz"]);
-assert_eq!(duplicates, ["bar", "Foo", "BAZ"]);
    
-
    🔬 This is a nightly-only experimental API. (slice_partition_dedup)

    Moves all but the first of consecutive elements to the end of the slice that resolve +assert_eq!(dedup, ["foo", "BAZ", "Bar", "baz"]); +assert_eq!(duplicates, ["bar", "Foo", "BAZ"]);

    +
    source

    pub fn partition_dedup_by_key<K, F>(&mut self, key: F) -> (&mut [T], &mut [T])where + F: FnMut(&mut T) -> K, + K: PartialEq<K>,

    🔬This is a nightly-only experimental API. (slice_partition_dedup)

    Moves all but the first of consecutive elements to the end of the slice that resolve to the same key.

    Returns two slices. The first contains no consecutive repeated elements. The second contains all the duplicates in no specified order.

    If the slice is sorted, the first returned slice contains no duplicates.

    -
    Examples
    -
    #![feature(slice_partition_dedup)]
+
    Examples
    
+
    #![feature(slice_partition_dedup)]
 
-let mut slice = [10, 20, 21, 30, 30, 20, 11, 13];
+let mut slice = [10, 20, 21, 30, 30, 20, 11, 13];
 
-let (dedup, duplicates) = slice.partition_dedup_by_key(|i| *i / 10);
+let (dedup, duplicates) = slice.partition_dedup_by_key(|i| *i / 10);
 
-assert_eq!(dedup, [10, 20, 30, 20, 11]);
-assert_eq!(duplicates, [21, 30, 13]);
    
-

    Rotates the slice in-place such that the first mid elements of the +assert_eq!(dedup, [10, 20, 30, 20, 11]); +assert_eq!(duplicates, [21, 30, 13]);

    +
    1.26.0 · source

    pub fn rotate_left(&mut self, mid: usize)

    Rotates the slice in-place such that the first mid elements of the slice move to the end while the last self.len() - mid elements move to the front. After calling rotate_left, the element previously at index mid will become the first element in the slice.

    -
    Panics
    +
    Panics

    This function will panic if mid is greater than the length of the slice. Note that mid == self.len() does not panic and is a no-op rotation.

    Complexity

    Takes linear (in self.len()) time.

    -
    Examples
    -
    let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
-a.rotate_left(2);
-assert_eq!(a, ['c', 'd', 'e', 'f', 'a', 'b']);
    +
    Examples
    +
    let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
+a.rotate_left(2);
+assert_eq!(a, ['c', 'd', 'e', 'f', 'a', 'b']);

    Rotating a subslice:

    -
    let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
-a[1..5].rotate_left(1);
-assert_eq!(a, ['a', 'c', 'd', 'e', 'b', 'f']);
    -

    Rotates the slice in-place such that the first self.len() - k +

    let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
+a[1..5].rotate_left(1);
+assert_eq!(a, ['a', 'c', 'd', 'e', 'b', 'f']);
    +
    1.26.0 · source

    pub fn rotate_right(&mut self, k: usize)

    Rotates the slice in-place such that the first self.len() - k elements of the slice move to the end while the last k elements move to the front. After calling rotate_right, the element previously at index self.len() - k will become the first element in the slice.

    -
    Panics
    +
    Panics

    This function will panic if k is greater than the length of the slice. Note that k == self.len() does not panic and is a no-op rotation.

    Complexity

    Takes linear (in self.len()) time.

    -
    Examples
    -
    let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
-a.rotate_right(2);
-assert_eq!(a, ['e', 'f', 'a', 'b', 'c', 'd']);
    -

    Rotate a subslice:

    +
    Examples
    +
    let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
+a.rotate_right(2);
+assert_eq!(a, ['e', 'f', 'a', 'b', 'c', 'd']);
    +

    Rotating a subslice:

    -
    let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
-a[1..5].rotate_right(1);
-assert_eq!(a, ['a', 'e', 'b', 'c', 'd', 'f']);
    -

    Fills self with elements by cloning value.

    -
    Examples
    -
    let mut buf = vec![0; 10];
-buf.fill(1);
-assert_eq!(buf, vec![1; 10]);
    -

    Fills self with elements returned by calling a closure repeatedly.

    +
    let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
+a[1..5].rotate_right(1);
+assert_eq!(a, ['a', 'e', 'b', 'c', 'd', 'f']);
    +
    1.50.0 · source

    pub fn fill(&mut self, value: T)where + T: Clone,

    Fills self with elements by cloning value.

    +
    Examples
    +
    let mut buf = vec![0; 10];
+buf.fill(1);
+assert_eq!(buf, vec![1; 10]);
    +
    1.51.0 · source

    pub fn fill_with<F>(&mut self, f: F)where + F: FnMut() -> T,

    Fills self with elements returned by calling a closure repeatedly.

    This method uses a closure to create new values. If you’d rather -Clone a given value, use fill. If you want to use the Default -trait to generate values, you can pass Default::default as the +Clone a given value, use fill. If you want to use the Default +trait to generate values, you can pass Default::default as the argument.

    -
    Examples
    -
    let mut buf = vec![1; 10];
-buf.fill_with(Default::default);
-assert_eq!(buf, vec![0; 10]);
    -

    Copies the elements from src into self.

    +
    Examples
    +
    let mut buf = vec![1; 10];
+buf.fill_with(Default::default);
+assert_eq!(buf, vec![0; 10]);
    +
    1.7.0 · source

    pub fn clone_from_slice(&mut self, src: &[T])where + T: Clone,

    Copies the elements from src into self.

    The length of src must be the same as self.

    -
    Panics
    +
    Panics

    This function will panic if the two slices have different lengths.

    -
    Examples
    +
    Examples

    Cloning two elements from a slice into another:

    -
    let src = [1, 2, 3, 4];
-let mut dst = [0, 0];
+
    let src = [1, 2, 3, 4];
+let mut dst = [0, 0];
 
-// Because the slices have to be the same length,
-// we slice the source slice from four elements
-// to two. It will panic if we don't do this.
-dst.clone_from_slice(&src[2..]);
+// Because the slices have to be the same length,
+// we slice the source slice from four elements
+// to two. It will panic if we don't do this.
+dst.clone_from_slice(&src[2..]);
 
-assert_eq!(src, [1, 2, 3, 4]);
-assert_eq!(dst, [3, 4]);
    
+assert_eq!(src, [1, 2, 3, 4]);
+assert_eq!(dst, [3, 4]);

    Rust enforces that there can only be one mutable reference with no immutable references to a particular piece of data in a particular scope. Because of this, attempting to use clone_from_slice on a single slice will result in a compile failure:

    -
    ⓘ
    let mut slice = [1, 2, 3, 4, 5];
+
    ⓘ
    let mut slice = [1, 2, 3, 4, 5];
 
-slice[..2].clone_from_slice(&slice[3..]); // compile fail!
    
-
    To work around this, we can use split_at_mut to create two distinct
+slice[..2].clone_from_slice(&slice[3..]); // compile fail!
    +

    To work around this, we can use split_at_mut to create two distinct sub-slices from a slice:

    -
    let mut slice = [1, 2, 3, 4, 5];
+
    let mut slice = [1, 2, 3, 4, 5];
 
 {
-    let (left, right) = slice.split_at_mut(2);
-    left.clone_from_slice(&right[1..]);
+    let (left, right) = slice.split_at_mut(2);
+    left.clone_from_slice(&right[1..]);
 }
 
-assert_eq!(slice, [4, 5, 3, 4, 5]);
    
-

    Copies all elements from src into self, using a memcpy.

    +assert_eq!(slice, [4, 5, 3, 4, 5]);
    +
    1.9.0 · source

    pub fn copy_from_slice(&mut self, src: &[T])where + T: Copy,

    Copies all elements from src into self, using a memcpy.

    The length of src must be the same as self.

    -

    If T does not implement Copy, use clone_from_slice.

    -
    Panics
    +

    If T does not implement Copy, use clone_from_slice.

    +
    Panics

    This function will panic if the two slices have different lengths.

    -
    Examples
    +
    Examples

    Copying two elements from a slice into another:

    -
    let src = [1, 2, 3, 4];
-let mut dst = [0, 0];
+
    let src = [1, 2, 3, 4];
+let mut dst = [0, 0];
 
-// Because the slices have to be the same length,
-// we slice the source slice from four elements
-// to two. It will panic if we don't do this.
-dst.copy_from_slice(&src[2..]);
+// Because the slices have to be the same length,
+// we slice the source slice from four elements
+// to two. It will panic if we don't do this.
+dst.copy_from_slice(&src[2..]);
 
-assert_eq!(src, [1, 2, 3, 4]);
-assert_eq!(dst, [3, 4]);
    
+assert_eq!(src, [1, 2, 3, 4]);
+assert_eq!(dst, [3, 4]);

    Rust enforces that there can only be one mutable reference with no immutable references to a particular piece of data in a particular scope. Because of this, attempting to use copy_from_slice on a single slice will result in a compile failure:

    -
    ⓘ
    let mut slice = [1, 2, 3, 4, 5];
+
    ⓘ
    let mut slice = [1, 2, 3, 4, 5];
 
-slice[..2].copy_from_slice(&slice[3..]); // compile fail!
    
-
    To work around this, we can use split_at_mut to create two distinct
+slice[..2].copy_from_slice(&slice[3..]); // compile fail!
    +

    To work around this, we can use split_at_mut to create two distinct sub-slices from a slice:

    -
    let mut slice = [1, 2, 3, 4, 5];
+
    let mut slice = [1, 2, 3, 4, 5];
 
 {
-    let (left, right) = slice.split_at_mut(2);
-    left.copy_from_slice(&right[1..]);
+    let (left, right) = slice.split_at_mut(2);
+    left.copy_from_slice(&right[1..]);
 }
 
-assert_eq!(slice, [4, 5, 3, 4, 5]);
    
-

    Copies elements from one part of the slice to another part of itself, +assert_eq!(slice, [4, 5, 3, 4, 5]);

    +
    1.37.0 · source

    pub fn copy_within<R>(&mut self, src: R, dest: usize)where + R: RangeBounds<usize>, + T: Copy,

    Copies elements from one part of the slice to another part of itself, using a memmove.

    src is the range within self to copy from. dest is the starting index of the range within self to copy to, which will have the same length as src. The two ranges may overlap. The ends of the two ranges must be less than or equal to self.len().

    -
    Panics
    +
    Panics

    This function will panic if either range exceeds the end of the slice, or if the end of src is before the start.

    -
    Examples
    +
    Examples

    Copying four bytes within a slice:

    -
    let mut bytes = *b"Hello, World!";
+
    let mut bytes = *b"Hello, World!";
 
-bytes.copy_within(1..5, 8);
+bytes.copy_within(1..5, 8);
 
-assert_eq!(&bytes, b"Hello, Wello!");
    
-

    Swaps all elements in self with those in other.

    +assert_eq!(&bytes, b"Hello, Wello!");
    +
    1.27.0 · source

    pub fn swap_with_slice(&mut self, other: &mut [T])

    Swaps all elements in self with those in other.

    The length of other must be the same as self.

    -
    Panics
    +
    Panics

    This function will panic if the two slices have different lengths.

    Example

    Swapping two elements across slices:

    -
    let mut slice1 = [0, 0];
-let mut slice2 = [1, 2, 3, 4];
+
    let mut slice1 = [0, 0];
+let mut slice2 = [1, 2, 3, 4];
 
-slice1.swap_with_slice(&mut slice2[2..]);
+slice1.swap_with_slice(&mut slice2[2..]);
 
-assert_eq!(slice1, [3, 4]);
-assert_eq!(slice2, [1, 2, 0, 0]);
    
+assert_eq!(slice1, [3, 4]);
+assert_eq!(slice2, [1, 2, 0, 0]);

    Rust enforces that there can only be one mutable reference to a particular piece of data in a particular scope. Because of this, attempting to use swap_with_slice on a single slice will result in a compile failure:

    -
    ⓘ
    let mut slice = [1, 2, 3, 4, 5];
-slice[..2].swap_with_slice(&mut slice[3..]); // compile fail!
    -

    To work around this, we can use split_at_mut to create two distinct +

    ⓘ
    let mut slice = [1, 2, 3, 4, 5];
+slice[..2].swap_with_slice(&mut slice[3..]); // compile fail!
    +

    To work around this, we can use split_at_mut to create two distinct mutable sub-slices from a slice:

    -
    let mut slice = [1, 2, 3, 4, 5];
+
    let mut slice = [1, 2, 3, 4, 5];
 
 {
-    let (left, right) = slice.split_at_mut(2);
-    left.swap_with_slice(&mut right[1..]);
+    let (left, right) = slice.split_at_mut(2);
+    left.swap_with_slice(&mut right[1..]);
 }
 
-assert_eq!(slice, [4, 5, 3, 1, 2]);
    
-

    Transmute the slice to a slice of another type, ensuring alignment of the types is +assert_eq!(slice, [4, 5, 3, 1, 2]);

    +
    1.30.0 · source

    pub unsafe fn align_to<U>(&self) -> (&[T], &[U], &[T])

    Transmute the slice to a slice of another type, ensuring alignment of the types is maintained.

    This method splits the slice into three distinct slices: prefix, correctly aligned middle -slice of a new type, and the suffix slice. The method may make the middle slice the greatest -length possible for a given type and input slice, but only your algorithm’s performance -should depend on that, not its correctness. It is permissible for all of the input data to -be returned as the prefix or suffix slice.

    -

    This method has no purpose when either input element T or output element U are -zero-sized and will return the original slice without splitting anything.

    -
    Safety
    -

    This method is essentially a transmute with respect to the elements in the returned -middle slice, so all the usual caveats pertaining to transmute::<T, U> also apply here.

    -
    Examples
    -

    Basic usage:

    - -
    unsafe {
-    let bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7];
-    let (prefix, shorts, suffix) = bytes.align_to::<u16>();
-    // less_efficient_algorithm_for_bytes(prefix);
-    // more_efficient_algorithm_for_aligned_shorts(shorts);
-    // less_efficient_algorithm_for_bytes(suffix);
-}
    -

    Transmute the slice to a slice of another type, ensuring alignment of the types is -maintained.

    -

    This method splits the slice into three distinct slices: prefix, correctly aligned middle -slice of a new type, and the suffix slice. The method may make the middle slice the greatest -length possible for a given type and input slice, but only your algorithm’s performance -should depend on that, not its correctness. It is permissible for all of the input data to -be returned as the prefix or suffix slice.

    +slice of a new type, and the suffix slice. How exactly the slice is split up is not +specified; the middle part may be smaller than necessary. However, if this fails to return a +maximal middle part, that is because code is running in a context where performance does not +matter, such as a sanitizer attempting to find alignment bugs. Regular code running +in a default (debug or release) execution will return a maximal middle part.

    This method has no purpose when either input element T or output element U are zero-sized and will return the original slice without splitting anything.

    Safety

    This method is essentially a transmute with respect to the elements in the returned middle slice, so all the usual caveats pertaining to transmute::<T, U> also apply here.

    -
    Examples
    +
    Examples

    Basic usage:

    -
    unsafe {
-    let mut bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7];
-    let (prefix, shorts, suffix) = bytes.align_to_mut::<u16>();
-    // less_efficient_algorithm_for_bytes(prefix);
-    // more_efficient_algorithm_for_aligned_shorts(shorts);
-    // less_efficient_algorithm_for_bytes(suffix);
-}
    -
    🔬 This is a nightly-only experimental API. (portable_simd)

    Split a slice into a prefix, a middle of aligned SIMD types, and a suffix.

    -

    This is a safe wrapper around slice::align_to, so has the same weak +

    unsafe {
+    let bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7];
+    let (prefix, shorts, suffix) = bytes.align_to::<u16>();
+    // less_efficient_algorithm_for_bytes(prefix);
+    // more_efficient_algorithm_for_aligned_shorts(shorts);
+    // less_efficient_algorithm_for_bytes(suffix);
+}
    +
    1.30.0 · source

    pub unsafe fn align_to_mut<U>(&mut self) -> (&mut [T], &mut [U], &mut [T])

    Transmute the mutable slice to a mutable slice of another type, ensuring alignment of the +types is maintained.

    +

    This method splits the slice into three distinct slices: prefix, correctly aligned middle +slice of a new type, and the suffix slice. How exactly the slice is split up is not +specified; the middle part may be smaller than necessary. However, if this fails to return a +maximal middle part, that is because code is running in a context where performance does not +matter, such as a sanitizer attempting to find alignment bugs. Regular code running +in a default (debug or release) execution will return a maximal middle part.

    +

    This method has no purpose when either input element T or output element U are +zero-sized and will return the original slice without splitting anything.

    +
    Safety
    +

    This method is essentially a transmute with respect to the elements in the returned +middle slice, so all the usual caveats pertaining to transmute::<T, U> also apply here.

    +
    Examples
    +

    Basic usage:

    + +
    unsafe {
+    let mut bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7];
+    let (prefix, shorts, suffix) = bytes.align_to_mut::<u16>();
+    // less_efficient_algorithm_for_bytes(prefix);
+    // more_efficient_algorithm_for_aligned_shorts(shorts);
+    // less_efficient_algorithm_for_bytes(suffix);
+}
    +
    source

    pub fn as_simd<const LANES: usize>(&self) -> (&[T], &[Simd<T, LANES>], &[T])where + Simd<T, LANES>: AsRef<[T; LANES]>, + T: SimdElement, + LaneCount<LANES>: SupportedLaneCount,

    🔬This is a nightly-only experimental API. (portable_simd)

    Split a slice into a prefix, a middle of aligned SIMD types, and a suffix.

    +

    This is a safe wrapper around slice::align_to, so has the same weak postconditions as that method. You’re only assured that self.len() == prefix.len() + middle.len() * LANES + suffix.len().

    Notably, all of the following are possible:

    @@ -1644,7 +1957,7 @@ postconditions as that method. You’re only assured that

    That said, this is a safe method, so if you’re only writing safe code, then this can at most cause incorrect logic, not unsoundness.

    -
    Panics
    +
    Panics

    This will panic if the size of the SIMD type is different from LANES times that of the scalar.

    At the time of writing, the trait restrictions on Simd<T, LANES> keeps @@ -1652,36 +1965,42 @@ that from ever happening, as only power-of-two numbers of lanes are supported. It’s possible that, in the future, those restrictions might be lifted in a way that would make it possible to see panics from this method for something like LANES == 3.

    -
    Examples
    -
    #![feature(portable_simd)]
-use core::simd::SimdFloat;
+
    Examples
    
+
    #![feature(portable_simd)]
+use core::simd::SimdFloat;
 
-let short = &[1, 2, 3];
-let (prefix, middle, suffix) = short.as_simd::<4>();
-assert_eq!(middle, []); // Not enough elements for anything in the middle
+let short = &[1, 2, 3];
+let (prefix, middle, suffix) = short.as_simd::<4>();
+assert_eq!(middle, []); // Not enough elements for anything in the middle
 
-// They might be split in any possible way between prefix and suffix
-let it = prefix.iter().chain(suffix).copied();
-assert_eq!(it.collect::<Vec<_>>(), vec![1, 2, 3]);
+// They might be split in any possible way between prefix and suffix
+let it = prefix.iter().chain(suffix).copied();
+assert_eq!(it.collect::<Vec<_>>(), vec![1, 2, 3]);
 
-fn basic_simd_sum(x: &[f32]) -> f32 {
-    use std::ops::Add;
-    use std::simd::f32x4;
-    let (prefix, middle, suffix) = x.as_simd();
-    let sums = f32x4::from_array([
-        prefix.iter().copied().sum(),
+fn basic_simd_sum(x: &[f32]) -> f32 {
+    use std::ops::Add;
+    use std::simd::f32x4;
+    let (prefix, middle, suffix) = x.as_simd();
+    let sums = f32x4::from_array([
+        prefix.iter().copied().sum(),
         0.0,
         0.0,
-        suffix.iter().copied().sum(),
+        suffix.iter().copied().sum(),
     ]);
-    let sums = middle.iter().copied().fold(sums, f32x4::add);
-    sums.reduce_sum()
+    let sums = middle.iter().copied().fold(sums, f32x4::add);
+    sums.reduce_sum()
 }
 
-let numbers: Vec<f32> = (1..101).map(|x| x as _).collect();
-assert_eq!(basic_simd_sum(&numbers[1..99]), 4949.0);
    
-
    🔬 This is a nightly-only experimental API. (portable_simd)

    Split a slice into a prefix, a middle of aligned SIMD types, and a suffix.

    -

    This is a safe wrapper around slice::align_to_mut, so has the same weak +let numbers: Vec<f32> = (1..101).map(|x| x as _).collect(); +assert_eq!(basic_simd_sum(&numbers[1..99]), 4949.0);

    +
    source

    pub fn as_simd_mut<const LANES: usize>( + &mut self +) -> (&mut [T], &mut [Simd<T, LANES>], &mut [T])where + Simd<T, LANES>: AsMut<[T; LANES]>, + T: SimdElement, + LaneCount<LANES>: SupportedLaneCount,

    🔬This is a nightly-only experimental API. (portable_simd)

    Split a mutable slice into a mutable prefix, a middle of aligned SIMD types, +and a mutable suffix.

    +

    This is a safe wrapper around slice::align_to_mut, so has the same weak postconditions as that method. You’re only assured that self.len() == prefix.len() + middle.len() * LANES + suffix.len().

    Notably, all of the following are possible:

    @@ -1692,8 +2011,8 @@ postconditions as that method. You’re only assured that

    That said, this is a safe method, so if you’re only writing safe code, then this can at most cause incorrect logic, not unsoundness.

    -

    This is the mutable version of slice::as_simd; see that for examples.

    -
    Panics
    +

    This is the mutable version of slice::as_simd; see that for examples.

    +
    Panics

    This will panic if the size of the SIMD type is different from LANES times that of the scalar.

    At the time of writing, the trait restrictions on Simd<T, LANES> keeps @@ -1701,234 +2020,231 @@ that from ever happening, as only power-of-two numbers of lanes are supported. It’s possible that, in the future, those restrictions might be lifted in a way that would make it possible to see panics from this method for something like LANES == 3.

    -
    🔬 This is a nightly-only experimental API. (is_sorted)

    Checks if the elements of this slice are sorted.

    +
    source

    pub fn is_sorted(&self) -> boolwhere + T: PartialOrd<T>,

    🔬This is a nightly-only experimental API. (is_sorted)

    Checks if the elements of this slice are sorted.

    That is, for each element a and its following element b, a <= b must hold. If the slice yields exactly zero or one element, true is returned.

    Note that if Self::Item is only PartialOrd, but not Ord, the above definition implies that this function returns false if any two consecutive items are not comparable.

    -
    Examples
    -
    #![feature(is_sorted)]
-let empty: [i32; 0] = [];
+
    Examples
    
+
    #![feature(is_sorted)]
+let empty: [i32; 0] = [];
 
-assert!([1, 2, 2, 9].is_sorted());
-assert!(![1, 3, 2, 4].is_sorted());
-assert!([0].is_sorted());
-assert!(empty.is_sorted());
-assert!(![0.0, 1.0, f32::NAN].is_sorted());
    
-
    🔬 This is a nightly-only experimental API. (is_sorted)

    Checks if the elements of this slice are sorted using the given comparator function.

    +assert!([1, 2, 2, 9].is_sorted()); +assert!(![1, 3, 2, 4].is_sorted()); +assert!([0].is_sorted()); +assert!(empty.is_sorted()); +assert!(![0.0, 1.0, f32::NAN].is_sorted());
    +
    source

    pub fn is_sorted_by<'a, F>(&'a self, compare: F) -> boolwhere + F: FnMut(&'a T, &'a T) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (is_sorted)

    Checks if the elements of this slice are sorted using the given comparator function.

    Instead of using PartialOrd::partial_cmp, this function uses the given compare function to determine the ordering of two elements. Apart from that, it’s equivalent to -is_sorted; see its documentation for more information.

    -
    🔬 This is a nightly-only experimental API. (is_sorted)

    Checks if the elements of this slice are sorted using the given key extraction function.

    +is_sorted; see its documentation for more information.

    +
    source

    pub fn is_sorted_by_key<'a, F, K>(&'a self, f: F) -> boolwhere + F: FnMut(&'a T) -> K, + K: PartialOrd<K>,

    🔬This is a nightly-only experimental API. (is_sorted)

    Checks if the elements of this slice are sorted using the given key extraction function.

    Instead of comparing the slice’s elements directly, this function compares the keys of the -elements, as determined by f. Apart from that, it’s equivalent to is_sorted; see its +elements, as determined by f. Apart from that, it’s equivalent to is_sorted; see its documentation for more information.

    -
    Examples
    -
    #![feature(is_sorted)]
+
    Examples
    
+
    #![feature(is_sorted)]
 
-assert!(["c", "bb", "aaa"].is_sorted_by_key(|s| s.len()));
-assert!(![-2i32, -1, 0, 3].is_sorted_by_key(|n| n.abs()));
    
-

    Returns the index of the partition point according to the given predicate +assert!(["c", "bb", "aaa"].is_sorted_by_key(|s| s.len())); +assert!(![-2i32, -1, 0, 3].is_sorted_by_key(|n| n.abs()));

    +
    1.52.0 · source

    pub fn partition_point<P>(&self, pred: P) -> usizewhere + P: FnMut(&T) -> bool,

    Returns the index of the partition point according to the given predicate (the index of the first element of the second partition).

    The slice is assumed to be partitioned according to the given predicate. This means that all elements for which the predicate returns true are at the start of the slice and all elements for which the predicate returns false are at the end. -For example, [7, 15, 3, 5, 4, 12, 6] is a partitioned under the predicate x % 2 != 0 +For example, [7, 15, 3, 5, 4, 12, 6] is partitioned under the predicate x % 2 != 0 (all odd numbers are at the start, all even at the end).

    If this slice is not partitioned, the returned result is unspecified and meaningless, as this method performs a kind of binary search.

    -

    See also binary_search, binary_search_by, and binary_search_by_key.

    -
    Examples
    -
    let v = [1, 2, 3, 3, 5, 6, 7];
-let i = v.partition_point(|&x| x < 5);
+
    See also binary_search, binary_search_by, and binary_search_by_key.
    
+
    Examples
    
+
    let v = [1, 2, 3, 3, 5, 6, 7];
+let i = v.partition_point(|&x| x < 5);
 
-assert_eq!(i, 4);
-assert!(v[..i].iter().all(|&x| x < 5));
-assert!(v[i..].iter().all(|&x| !(x < 5)));
    
+assert_eq!(i, 4);
+assert!(v[..i].iter().all(|&x| x < 5));
+assert!(v[i..].iter().all(|&x| !(x < 5)));
    +

    If all elements of the slice match the predicate, including if the slice +is empty, then the length of the slice will be returned:

    + +
    let a = [2, 4, 8];
+assert_eq!(a.partition_point(|x| x < &100), a.len());
+let a: [i32; 0] = [];
+assert_eq!(a.partition_point(|x| x < &100), 0);

    If you want to insert an item to a sorted vector, while maintaining sort order:

    -
    let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
-let num = 42;
-let idx = s.partition_point(|&x| x < num);
-s.insert(idx, num);
-assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
    -
    🔬 This is a nightly-only experimental API. (slice_take)

    Removes the subslice corresponding to the given range +

    let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
+let num = 42;
+let idx = s.partition_point(|&x| x < num);
+s.insert(idx, num);
+assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
    +
    source

    pub fn take<R, 'a>(self: &mut &'a [T], range: R) -> Option<&'a [T]>where + R: OneSidedRange<usize>,

    🔬This is a nightly-only experimental API. (slice_take)

    Removes the subslice corresponding to the given range and returns a reference to it.

    Returns None and does not modify the slice if the given range is out of bounds.

    Note that this method only accepts one-sided ranges such as 2.. or ..6, but not 2..6.

    -
    Examples
    +
    Examples

    Taking the first three elements of a slice:

    -
    #![feature(slice_take)]
+
    #![feature(slice_take)]
 
-let mut slice: &[_] = &['a', 'b', 'c', 'd'];
-let mut first_three = slice.take(..3).unwrap();
+let mut slice: &[_] = &['a', 'b', 'c', 'd'];
+let mut first_three = slice.take(..3).unwrap();
 
-assert_eq!(slice, &['d']);
-assert_eq!(first_three, &['a', 'b', 'c']);
    
+assert_eq!(slice, &['d']);
+assert_eq!(first_three, &['a', 'b', 'c']);

    Taking the last two elements of a slice:

    -
    #![feature(slice_take)]
+
    #![feature(slice_take)]
 
-let mut slice: &[_] = &['a', 'b', 'c', 'd'];
-let mut tail = slice.take(2..).unwrap();
+let mut slice: &[_] = &['a', 'b', 'c', 'd'];
+let mut tail = slice.take(2..).unwrap();
 
-assert_eq!(slice, &['a', 'b']);
-assert_eq!(tail, &['c', 'd']);
    
+assert_eq!(slice, &['a', 'b']);
+assert_eq!(tail, &['c', 'd']);

    Getting None when range is out of bounds:

    -
    #![feature(slice_take)]
+
    #![feature(slice_take)]
 
-let mut slice: &[_] = &['a', 'b', 'c', 'd'];
+let mut slice: &[_] = &['a', 'b', 'c', 'd'];
 
-assert_eq!(None, slice.take(5..));
-assert_eq!(None, slice.take(..5));
-assert_eq!(None, slice.take(..=4));
-let expected: &[char] = &['a', 'b', 'c', 'd'];
-assert_eq!(Some(expected), slice.take(..4));
    
-
    🔬 This is a nightly-only experimental API. (slice_take)

    Removes the subslice corresponding to the given range +assert_eq!(None, slice.take(5..)); +assert_eq!(None, slice.take(..5)); +assert_eq!(None, slice.take(..=4)); +let expected: &[char] = &['a', 'b', 'c', 'd']; +assert_eq!(Some(expected), slice.take(..4));

    +
    source

    pub fn take_mut<R, 'a>(self: &mut &'a mut [T], range: R) -> Option<&'a mut [T]>where + R: OneSidedRange<usize>,

    🔬This is a nightly-only experimental API. (slice_take)

    Removes the subslice corresponding to the given range and returns a mutable reference to it.

    Returns None and does not modify the slice if the given range is out of bounds.

    Note that this method only accepts one-sided ranges such as 2.. or ..6, but not 2..6.

    -
    Examples
    +
    Examples

    Taking the first three elements of a slice:

    -
    #![feature(slice_take)]
+
    #![feature(slice_take)]
 
-let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
-let mut first_three = slice.take_mut(..3).unwrap();
+let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
+let mut first_three = slice.take_mut(..3).unwrap();
 
-assert_eq!(slice, &mut ['d']);
-assert_eq!(first_three, &mut ['a', 'b', 'c']);
    
+assert_eq!(slice, &mut ['d']);
+assert_eq!(first_three, &mut ['a', 'b', 'c']);

    Taking the last two elements of a slice:

    -
    #![feature(slice_take)]
+
    #![feature(slice_take)]
 
-let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
-let mut tail = slice.take_mut(2..).unwrap();
+let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
+let mut tail = slice.take_mut(2..).unwrap();
 
-assert_eq!(slice, &mut ['a', 'b']);
-assert_eq!(tail, &mut ['c', 'd']);
    
+assert_eq!(slice, &mut ['a', 'b']);
+assert_eq!(tail, &mut ['c', 'd']);

    Getting None when range is out of bounds:

    -
    #![feature(slice_take)]
+
    #![feature(slice_take)]
 
-let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
+let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
 
-assert_eq!(None, slice.take_mut(5..));
-assert_eq!(None, slice.take_mut(..5));
-assert_eq!(None, slice.take_mut(..=4));
-let expected: &mut [_] = &mut ['a', 'b', 'c', 'd'];
-assert_eq!(Some(expected), slice.take_mut(..4));
    
-
    🔬 This is a nightly-only experimental API. (slice_take)

    Removes the first element of the slice and returns a reference +assert_eq!(None, slice.take_mut(5..)); +assert_eq!(None, slice.take_mut(..5)); +assert_eq!(None, slice.take_mut(..=4)); +let expected: &mut [_] = &mut ['a', 'b', 'c', 'd']; +assert_eq!(Some(expected), slice.take_mut(..4));

    +
    source

    pub fn take_first<'a>(self: &mut &'a [T]) -> Option<&'a T>

    🔬This is a nightly-only experimental API. (slice_take)

    Removes the first element of the slice and returns a reference to it.

    Returns None if the slice is empty.

    -
    Examples
    -
    #![feature(slice_take)]
+
    Examples
    
+
    #![feature(slice_take)]
 
-let mut slice: &[_] = &['a', 'b', 'c'];
-let first = slice.take_first().unwrap();
+let mut slice: &[_] = &['a', 'b', 'c'];
+let first = slice.take_first().unwrap();
 
-assert_eq!(slice, &['b', 'c']);
-assert_eq!(first, &'a');
    
-
    🔬 This is a nightly-only experimental API. (slice_take)

    Removes the first element of the slice and returns a mutable +assert_eq!(slice, &['b', 'c']); +assert_eq!(first, &'a');

    +
    source

    pub fn take_first_mut<'a>(self: &mut &'a mut [T]) -> Option<&'a mut T>

    🔬This is a nightly-only experimental API. (slice_take)

    Removes the first element of the slice and returns a mutable reference to it.

    Returns None if the slice is empty.

    -
    Examples
    -
    #![feature(slice_take)]
+
    Examples
    
+
    #![feature(slice_take)]
 
-let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
-let first = slice.take_first_mut().unwrap();
-*first = 'd';
+let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
+let first = slice.take_first_mut().unwrap();
+*first = 'd';
 
-assert_eq!(slice, &['b', 'c']);
-assert_eq!(first, &'d');
    
-
    🔬 This is a nightly-only experimental API. (slice_take)

    Removes the last element of the slice and returns a reference +assert_eq!(slice, &['b', 'c']); +assert_eq!(first, &'d');

    +
    source

    pub fn take_last<'a>(self: &mut &'a [T]) -> Option<&'a T>

    🔬This is a nightly-only experimental API. (slice_take)

    Removes the last element of the slice and returns a reference to it.

    Returns None if the slice is empty.

    -
    Examples
    -
    #![feature(slice_take)]
+
    Examples
    
+
    #![feature(slice_take)]
 
-let mut slice: &[_] = &['a', 'b', 'c'];
-let last = slice.take_last().unwrap();
+let mut slice: &[_] = &['a', 'b', 'c'];
+let last = slice.take_last().unwrap();
 
-assert_eq!(slice, &['a', 'b']);
-assert_eq!(last, &'c');
    
-
    🔬 This is a nightly-only experimental API. (slice_take)

    Removes the last element of the slice and returns a mutable +assert_eq!(slice, &['a', 'b']); +assert_eq!(last, &'c');

    +
    source

    pub fn take_last_mut<'a>(self: &mut &'a mut [T]) -> Option<&'a mut T>

    🔬This is a nightly-only experimental API. (slice_take)

    Removes the last element of the slice and returns a mutable reference to it.

    Returns None if the slice is empty.

    -
    Examples
    -
    #![feature(slice_take)]
+
    Examples
    
+
    #![feature(slice_take)]
 
-let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
-let last = slice.take_last_mut().unwrap();
-*last = 'd';
+let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
+let last = slice.take_last_mut().unwrap();
+*last = 'd';
 
-assert_eq!(slice, &['a', 'b']);
-assert_eq!(last, &'d');
    
-
    🔬 This is a nightly-only experimental API. (sort_floats)

    Sorts the slice of floats.

    -

    This sort is in-place (i.e. does not allocate), O(n * log(n)) worst-case, and uses -the ordering defined by f32::total_cmp.

    -
    Current implementation
    -

    This uses the same sorting algorithm as sort_unstable_by.

    -
    Examples
    -
    #![feature(sort_floats)]
-let mut v = [2.6, -5e-8, f32::NAN, 8.29, f32::INFINITY, -1.0, 0.0, -f32::INFINITY, -0.0];
+assert_eq!(slice, &['a', 'b']);
+assert_eq!(last, &'d');
    +
    source

    pub unsafe fn get_many_unchecked_mut<const N: usize>( + &mut self, + indices: [usize; N] +) -> [&mut T; N]

    🔬This is a nightly-only experimental API. (get_many_mut)

    Returns mutable references to many indices at once, without doing any checks.

    +

    For a safe alternative see get_many_mut.

    +
    Safety
    +

    Calling this method with overlapping or out-of-bounds indices is undefined behavior +even if the resulting references are not used.

    +
    Examples
    +
    #![feature(get_many_mut)]
 
-v.sort_floats();
-let sorted = [-f32::INFINITY, -1.0, -5e-8, -0.0, 0.0, 2.6, 8.29, f32::INFINITY, f32::NAN];
-assert_eq!(&v[..8], &sorted[..8]);
-assert!(v[8].is_nan());
    -
    🔬 This is a nightly-only experimental API. (slice_flatten)

    Takes a &[[T; N]], and flattens it to a &[T].

    -
    Panics
    -

    This panics if the length of the resulting slice would overflow a usize.

    -

    This is only possible when flattening a slice of arrays of zero-sized -types, and thus tends to be irrelevant in practice. If -size_of::<T>() > 0, this will never panic.

    -
    Examples
    -
    #![feature(slice_flatten)]
+let x = &mut [1, 2, 4];
 
-assert_eq!([[1, 2, 3], [4, 5, 6]].flatten(), &[1, 2, 3, 4, 5, 6]);
-
-assert_eq!(
-    [[1, 2, 3], [4, 5, 6]].flatten(),
-    [[1, 2], [3, 4], [5, 6]].flatten(),
-);
-
-let slice_of_empty_arrays: &[[i32; 0]] = &[[], [], [], [], []];
-assert!(slice_of_empty_arrays.flatten().is_empty());
-
-let empty_slice_of_arrays: &[[u32; 10]] = &[];
-assert!(empty_slice_of_arrays.flatten().is_empty());
    -
    🔬 This is a nightly-only experimental API. (slice_flatten)

    Takes a &mut [[T; N]], and flattens it to a &mut [T].

    -
    Panics
    -

    This panics if the length of the resulting slice would overflow a usize.

    -

    This is only possible when flattening a slice of arrays of zero-sized -types, and thus tends to be irrelevant in practice. If -size_of::<T>() > 0, this will never panic.

    -
    Examples
    -
    #![feature(slice_flatten)]
-
-fn add_5_to_all(slice: &mut [i32]) {
-    for i in slice {
-        *i += 5;
-    }
+unsafe {
+    let [a, b] = x.get_many_unchecked_mut([0, 2]);
+    *a *= 10;
+    *b *= 100;
 }
+assert_eq!(x, &[10, 2, 400]);
    +
    source

    pub fn get_many_mut<const N: usize>( + &mut self, + indices: [usize; N] +) -> Result<[&mut T; N], GetManyMutError<N>>

    🔬This is a nightly-only experimental API. (get_many_mut)

    Returns mutable references to many indices at once.

    +

    Returns an error if any index is out-of-bounds, or if the same index was +passed more than once.

    +
    Examples
    +
    #![feature(get_many_mut)]
 
-let mut array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
-add_5_to_all(array.flatten_mut());
-assert_eq!(array, [[6, 7, 8], [9, 10, 11], [12, 13, 14]]);
    -

    Sorts the slice.

    +let v = &mut [1, 2, 3]; +if let Ok([a, b]) = v.get_many_mut([0, 2]) { + *a = 413; + *b = 612; +} +assert_eq!(v, &[413, 2, 612]);
    +
    1.0.0 · source

    pub fn sort(&mut self)where + T: Ord,

    Sorts the slice.

    This sort is stable (i.e., does not reorder equal elements) and O(n * log(n)) worst-case.

    When applicable, unstable sorting is preferred because it is generally faster than stable sorting and it doesn’t allocate auxiliary memory. -See sort_unstable.

    +See sort_unstable.

    Current implementation

    The current algorithm is an adaptive, iterative merge sort inspired by timsort. @@ -1936,12 +2252,13 @@ It is designed to be very fast in cases where the slice is nearly sorted, or con two or more sorted sequences concatenated one after another.

    Also, it allocates temporary storage half the size of self, but for short slices a non-allocating insertion sort is used instead.

    -
    Examples
    -
    let mut v = [-5, 4, 1, -3, 2];
+
    Examples
    
+
    let mut v = [-5, 4, 1, -3, 2];
 
-v.sort();
-assert!(v == [-5, -3, 1, 2, 4]);
    
-

    Sorts the slice with a comparator function.

    +v.sort(); +assert!(v == [-5, -3, 1, 2, 4]);
    +
    1.0.0 · source

    pub fn sort_by<F>(&mut self, compare: F)where + F: FnMut(&T, &T) -> Ordering,

    Sorts the slice with a comparator function.

    This sort is stable (i.e., does not reorder equal elements) and O(n * log(n)) worst-case.

    The comparator function must define a total ordering for the elements in the slice. If the ordering is not total, the order of the elements is unspecified. An order is a @@ -1950,15 +2267,15 @@ total order if it is (for all a, b and c)

  • total and antisymmetric: exactly one of a < b, a == b or a > b is true, and
  • transitive, a < b and b < c implies a < c. The same must hold for both == and >.
    • -

    For example, while f64 doesn’t implement Ord because NaN != NaN, we can use +

    For example, while f64 doesn’t implement Ord because NaN != NaN, we can use partial_cmp as our sort function when we know the slice doesn’t contain a NaN.

    -
    let mut floats = [5f64, 4.0, 1.0, 3.0, 2.0];
-floats.sort_by(|a, b| a.partial_cmp(b).unwrap());
-assert_eq!(floats, [1.0, 2.0, 3.0, 4.0, 5.0]);
    +
    let mut floats = [5f64, 4.0, 1.0, 3.0, 2.0];
+floats.sort_by(|a, b| a.partial_cmp(b).unwrap());
+assert_eq!(floats, [1.0, 2.0, 3.0, 4.0, 5.0]);

    When applicable, unstable sorting is preferred because it is generally faster than stable sorting and it doesn’t allocate auxiliary memory. -See sort_unstable_by.

    +See sort_unstable_by.

    Current implementation

    The current algorithm is an adaptive, iterative merge sort inspired by timsort. @@ -1966,23 +2283,25 @@ It is designed to be very fast in cases where the slice is nearly sorted, or con two or more sorted sequences concatenated one after another.

    Also, it allocates temporary storage half the size of self, but for short slices a non-allocating insertion sort is used instead.

    -
    Examples
    -
    let mut v = [5, 4, 1, 3, 2];
-v.sort_by(|a, b| a.cmp(b));
-assert!(v == [1, 2, 3, 4, 5]);
+
    Examples
    
+
    let mut v = [5, 4, 1, 3, 2];
+v.sort_by(|a, b| a.cmp(b));
+assert!(v == [1, 2, 3, 4, 5]);
 
-// reverse sorting
-v.sort_by(|a, b| b.cmp(a));
-assert!(v == [5, 4, 3, 2, 1]);
    
-

    Sorts the slice with a key extraction function.

    +// reverse sorting +v.sort_by(|a, b| b.cmp(a)); +assert!(v == [5, 4, 3, 2, 1]);
    +
    1.7.0 · source

    pub fn sort_by_key<K, F>(&mut self, f: F)where + F: FnMut(&T) -> K, + K: Ord,

    Sorts the slice with a key extraction function.

    This sort is stable (i.e., does not reorder equal elements) and O(m * n * log(n)) worst-case, where the key function is O(m).

    For expensive key functions (e.g. functions that are not simple property accesses or -basic operations), sort_by_cached_key is likely to be +basic operations), sort_by_cached_key is likely to be significantly faster, as it does not recompute element keys.

    When applicable, unstable sorting is preferred because it is generally faster than stable sorting and it doesn’t allocate auxiliary memory. -See sort_unstable_by_key.

    +See sort_unstable_by_key.

    Current implementation

    The current algorithm is an adaptive, iterative merge sort inspired by timsort. @@ -1990,12 +2309,14 @@ It is designed to be very fast in cases where the slice is nearly sorted, or con two or more sorted sequences concatenated one after another.

    Also, it allocates temporary storage half the size of self, but for short slices a non-allocating insertion sort is used instead.

    -
    Examples
    -
    let mut v = [-5i32, 4, 1, -3, 2];
+
    Examples
    
+
    let mut v = [-5i32, 4, 1, -3, 2];
 
-v.sort_by_key(|k| k.abs());
-assert!(v == [1, 2, -3, 4, -5]);
    
-

    Sorts the slice with a key extraction function.

    +v.sort_by_key(|k| k.abs()); +assert!(v == [1, 2, -3, 4, -5]);
    +
    1.34.0 · source

    pub fn sort_by_cached_key<K, F>(&mut self, f: F)where + F: FnMut(&T) -> K, + K: Ord,

    Sorts the slice with a key extraction function.

    During sorting, the key function is called at most once per element, by using temporary storage to remember the results of key evaluation. The order of calls to the key function is unspecified and may change in future versions @@ -2003,7 +2324,7 @@ of the standard library.

    This sort is stable (i.e., does not reorder equal elements) and O(m * n + n * log(n)) worst-case, where the key function is O(m).

    For simple key functions (e.g., functions that are property accesses or -basic operations), sort_by_key is likely to be +basic operations), sort_by_key is likely to be faster.

    Current implementation

    The current algorithm is based on pattern-defeating quicksort by Orson Peters, @@ -2013,73 +2334,83 @@ randomization to avoid degenerate cases, but with a fixed seed to always provide deterministic behavior.

    In the worst case, the algorithm allocates temporary storage in a Vec<(K, usize)> the length of the slice.

    -
    Examples
    -
    let mut v = [-5i32, 4, 32, -3, 2];
+
    Examples
    
+
    let mut v = [-5i32, 4, 32, -3, 2];
 
-v.sort_by_cached_key(|k| k.to_string());
-assert!(v == [-3, -5, 2, 32, 4]);
    
-

    Copies self into a new Vec.

    -
    Examples
    -
    let s = [10, 40, 30];
-let x = s.to_vec();
+v.sort_by_cached_key(|k| k.to_string());
+assert!(v == [-3, -5, 2, 32, 4]);
    +
    1.0.0 · source

    pub fn to_vec(&self) -> Vec<T, Global>where + T: Clone,

    Copies self into a new Vec.

    +
    Examples
    +
    let s = [10, 40, 30];
+let x = s.to_vec();
 // Here, `s` and `x` can be modified independently.
    -
    🔬 This is a nightly-only experimental API. (allocator_api)

    Copies self into a new Vec with an allocator.

    -
    Examples
    -
    #![feature(allocator_api)]
+
    source

    pub fn to_vec_in<A>(&self, alloc: A) -> Vec<T, A>where + A: Allocator, + T: Clone,

    🔬This is a nightly-only experimental API. (allocator_api)

    Copies self into a new Vec with an allocator.

    +
    Examples
    +
    #![feature(allocator_api)]
 
-use std::alloc::System;
+use std::alloc::System;
 
-let s = [10, 40, 30];
-let x = s.to_vec_in(System);
+let s = [10, 40, 30];
+let x = s.to_vec_in(System);
 // Here, `s` and `x` can be modified independently.
    -

    Creates a vector by repeating a slice n times.

    +
    1.40.0 · source

    pub fn repeat(&self, n: usize) -> Vec<T, Global>where + T: Copy,

    Creates a vector by copying a slice n times.

    Panics

    This function will panic if the capacity would overflow.

    -
    Examples
    +
    Examples

    Basic usage:

    -
    assert_eq!([1, 2].repeat(3), vec![1, 2, 1, 2, 1, 2]);
    +
    assert_eq!([1, 2].repeat(3), vec![1, 2, 1, 2, 1, 2]);

    A panic upon overflow:

    -
    ⓘ
    // this will panic at runtime
-b"0123456789abcdef".repeat(usize::MAX);
    -

    Flattens a slice of T into a single value Self::Output.

    -
    Examples
    -
    assert_eq!(["hello", "world"].concat(), "helloworld");
-assert_eq!([[1, 2], [3, 4]].concat(), [1, 2, 3, 4]);
    -

    Flattens a slice of T into a single value Self::Output, placing a +

    ⓘ
    // this will panic at runtime
+b"0123456789abcdef".repeat(usize::MAX);
    +
    1.0.0 · source

    pub fn concat<Item>(&self) -> <[T] as Concat<Item>>::Outputwhere + [T]: Concat<Item>, + Item: ?Sized,

    Flattens a slice of T into a single value Self::Output.

    +
    Examples
    +
    assert_eq!(["hello", "world"].concat(), "helloworld");
+assert_eq!([[1, 2], [3, 4]].concat(), [1, 2, 3, 4]);
    +
    1.3.0 · source

    pub fn join<Separator>( + &self, + sep: Separator +) -> <[T] as Join<Separator>>::Outputwhere + [T]: Join<Separator>,

    Flattens a slice of T into a single value Self::Output, placing a given separator between each.

    -
    Examples
    -
    assert_eq!(["hello", "world"].join(" "), "hello world");
-assert_eq!([[1, 2], [3, 4]].join(&0), [1, 2, 0, 3, 4]);
-assert_eq!([[1, 2], [3, 4]].join(&[0, 0][..]), [1, 2, 0, 0, 3, 4]);
    -
    👎 Deprecated since 1.3.0:

    renamed to join

    -

    Flattens a slice of T into a single value Self::Output, placing a +

    Examples
    +
    assert_eq!(["hello", "world"].join(" "), "hello world");
+assert_eq!([[1, 2], [3, 4]].join(&0), [1, 2, 0, 3, 4]);
+assert_eq!([[1, 2], [3, 4]].join(&[0, 0][..]), [1, 2, 0, 0, 3, 4]);
    +
    1.0.0 · source

    pub fn connect<Separator>( + &self, + sep: Separator +) -> <[T] as Join<Separator>>::Outputwhere + [T]: Join<Separator>,

    👎Deprecated since 1.3.0: renamed to join

    Flattens a slice of T into a single value Self::Output, placing a given separator between each.

    -
    Examples
    -
    assert_eq!(["hello", "world"].connect(" "), "hello world");
-assert_eq!([[1, 2], [3, 4]].connect(&0), [1, 2, 0, 3, 4]);
    -

    Returns a vector containing a copy of this slice where each byte +

    Examples
    +
    assert_eq!(["hello", "world"].connect(" "), "hello world");
+assert_eq!([[1, 2], [3, 4]].connect(&0), [1, 2, 0, 3, 4]);
    +
    1.23.0 · source

    pub fn to_ascii_uppercase(&self) -> Vec<u8, Global>

    Returns a vector containing a copy of this slice where each byte is mapped to its ASCII upper case equivalent.

    ASCII letters ‘a’ to ‘z’ are mapped to ‘A’ to ‘Z’, but non-ASCII letters are unchanged.

    -

    To uppercase the value in-place, use make_ascii_uppercase.

    -

    Returns a vector containing a copy of this slice where each byte +

    To uppercase the value in-place, use make_ascii_uppercase.

    +
    1.23.0 · source

    pub fn to_ascii_lowercase(&self) -> Vec<u8, Global>

    Returns a vector containing a copy of this slice where each byte is mapped to its ASCII lower case equivalent.

    ASCII letters ‘A’ to ‘Z’ are mapped to ‘a’ to ‘z’, but non-ASCII letters are unchanged.

    -

    To lowercase the value in-place, use make_ascii_lowercase.

    -

    Trait Implementations

    The resulting type after dereferencing.

    -

    Dereferences the value.

    -

    Auto Trait Implementations

    Blanket Implementations

    Gets the TypeId of self. Read more

    -

    Immutably borrows from an owned value. Read more

    -

    Mutably borrows from an owned value. Read more

    -

    Returns the argument unchanged.

    -

    Calls U::from(self).

    +

    To lowercase the value in-place, use make_ascii_lowercase.

    +

    Trait Implementations§

    source§

    impl Deref for APP_NAMES

    §

    type Target = Vec<&'static str, Global>

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &Vec<&'static str>

    Dereferences the value.
    source§

    impl LazyStatic for APP_NAMES

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/macro.print.html b/ch5/os/macro.print.html index e95368c8..be9fdef8 100644 --- a/ch5/os/macro.print.html +++ b/ch5/os/macro.print.html @@ -1,5 +1,4 @@ -print in os - Rust

    Macro os::print

    source · [−]
    macro_rules! print {
-    ($fmt: literal $(, $($arg: tt)+)?) => { ... };
-}
    -
    Expand description

    print string macro

    -
    \ No newline at end of file +print in os - Rust

    Macro os::print

    source · 
    macro_rules! print {
+    ($fmt: literal $(, $($arg: tt)+)?) => { ... };
+}
    Expand description

    print string macro

    +
    \ No newline at end of file diff --git a/ch5/os/macro.println.html b/ch5/os/macro.println.html index c11546c7..2117ac86 100644 --- a/ch5/os/macro.println.html +++ b/ch5/os/macro.println.html @@ -1,5 +1,4 @@ -println in os - Rust

    Macro os::println

    source · [−]
    macro_rules! println {
-    ($fmt: literal $(, $($arg: tt)+)?) => { ... };
-}
    -
    Expand description

    println string macro

    -
    \ No newline at end of file +println in os - Rust

    Macro os::println

    source · 
    macro_rules! println {
+    ($fmt: literal $(, $($arg: tt)+)?) => { ... };
+}
    Expand description

    println string macro

    +
    \ No newline at end of file diff --git a/ch5/os/mm/address/constant.PA_WIDTH_SV39.html b/ch5/os/mm/address/constant.PA_WIDTH_SV39.html index 8b089bc7..bf92fdf9 100644 --- a/ch5/os/mm/address/constant.PA_WIDTH_SV39.html +++ b/ch5/os/mm/address/constant.PA_WIDTH_SV39.html @@ -1,2 +1,2 @@ -PA_WIDTH_SV39 in os::mm::address - Rust

    Constant os::mm::address::PA_WIDTH_SV39

    source · [−]
    const PA_WIDTH_SV39: usize = 56;
    Expand description

    physical address

    -
    \ No newline at end of file +PA_WIDTH_SV39 in os::mm::address - Rust

    Constant os::mm::address::PA_WIDTH_SV39

    source · 
    const PA_WIDTH_SV39: usize = 56;
    Expand description

    physical address

    +
    \ No newline at end of file diff --git a/ch5/os/mm/address/constant.PPN_WIDTH_SV39.html b/ch5/os/mm/address/constant.PPN_WIDTH_SV39.html index b17cc01a..23c5ffdd 100644 --- a/ch5/os/mm/address/constant.PPN_WIDTH_SV39.html +++ b/ch5/os/mm/address/constant.PPN_WIDTH_SV39.html @@ -1 +1 @@ -PPN_WIDTH_SV39 in os::mm::address - Rust

    Constant os::mm::address::PPN_WIDTH_SV39

    source · [−]
    const PPN_WIDTH_SV39: usize = _; // 44usize
    \ No newline at end of file +PPN_WIDTH_SV39 in os::mm::address - Rust

    Constant os::mm::address::PPN_WIDTH_SV39

    source · 
    const PPN_WIDTH_SV39: usize = _; // 44usize
    \ No newline at end of file diff --git a/ch5/os/mm/address/constant.VA_WIDTH_SV39.html b/ch5/os/mm/address/constant.VA_WIDTH_SV39.html index abea1f5c..f2a5525e 100644 --- a/ch5/os/mm/address/constant.VA_WIDTH_SV39.html +++ b/ch5/os/mm/address/constant.VA_WIDTH_SV39.html @@ -1 +1 @@ -VA_WIDTH_SV39 in os::mm::address - Rust

    Constant os::mm::address::VA_WIDTH_SV39

    source · [−]
    const VA_WIDTH_SV39: usize = 39;
    \ No newline at end of file +VA_WIDTH_SV39 in os::mm::address - Rust

    Constant os::mm::address::VA_WIDTH_SV39

    source · 
    const VA_WIDTH_SV39: usize = 39;
    \ No newline at end of file diff --git a/ch5/os/mm/address/constant.VPN_WIDTH_SV39.html b/ch5/os/mm/address/constant.VPN_WIDTH_SV39.html index e9f70312..b8b1ba49 100644 --- a/ch5/os/mm/address/constant.VPN_WIDTH_SV39.html +++ b/ch5/os/mm/address/constant.VPN_WIDTH_SV39.html @@ -1 +1 @@ -VPN_WIDTH_SV39 in os::mm::address - Rust

    Constant os::mm::address::VPN_WIDTH_SV39

    source · [−]
    const VPN_WIDTH_SV39: usize = _; // 27usize
    \ No newline at end of file +VPN_WIDTH_SV39 in os::mm::address - Rust

    Constant os::mm::address::VPN_WIDTH_SV39

    source · 
    const VPN_WIDTH_SV39: usize = _; // 27usize
    \ No newline at end of file diff --git a/ch5/os/mm/address/index.html b/ch5/os/mm/address/index.html index 24c01bf2..3fd00c75 100644 --- a/ch5/os/mm/address/index.html +++ b/ch5/os/mm/address/index.html @@ -1,10 +1,2 @@ -os::mm::address - Rust

    Module os::mm::address

    source · [−]
    Expand description

    Implementation of physical and virtual address and page number.

    -

    Structs

    PhysAddr

    physical address

    -
    PhysPageNum

    physical page number

    -
    SimpleRange

    a simple range structure for type T

    -
    SimpleRangeIterator

    iterator for the simple range structure

    -
    VirtAddr

    virtual address

    -
    VirtPageNum

    virtual page number

    -

    Constants

    PA_WIDTH_SV39 🔒

    physical address

    -
    PPN_WIDTH_SV39 🔒
    VA_WIDTH_SV39 🔒
    VPN_WIDTH_SV39 🔒

    Traits

    StepByOne

    Type Definitions

    VPNRange

    a simple range structure for virtual page number

    -
    \ No newline at end of file +os::mm::address - Rust

    Module os::mm::address

    source ·
    Expand description

    Implementation of physical and virtual address and page number.

    +

    Structs

    Constants

    Traits

    Type Aliases

    • VPNRange
      a simple range structure for virtual page number
    \ No newline at end of file diff --git a/ch5/os/mm/address/sidebar-items.js b/ch5/os/mm/address/sidebar-items.js index e11536d5..60e19a5a 100644 --- a/ch5/os/mm/address/sidebar-items.js +++ b/ch5/os/mm/address/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"constant":[["PA_WIDTH_SV39","physical address"],["PPN_WIDTH_SV39",""],["VA_WIDTH_SV39",""],["VPN_WIDTH_SV39",""]],"struct":[["PhysAddr","physical address"],["PhysPageNum","physical page number"],["SimpleRange","a simple range structure for type T"],["SimpleRangeIterator","iterator for the simple range structure"],["VirtAddr","virtual address"],["VirtPageNum","virtual page number"]],"trait":[["StepByOne",""]],"type":[["VPNRange","a simple range structure for virtual page number"]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"constant":["PA_WIDTH_SV39","PPN_WIDTH_SV39","VA_WIDTH_SV39","VPN_WIDTH_SV39"],"struct":["PhysAddr","PhysPageNum","SimpleRange","SimpleRangeIterator","VirtAddr","VirtPageNum"],"trait":["StepByOne"],"type":["VPNRange"]}; \ No newline at end of file diff --git a/ch5/os/mm/address/struct.PhysAddr.html b/ch5/os/mm/address/struct.PhysAddr.html index 3ddd87e7..a306590f 100644 --- a/ch5/os/mm/address/struct.PhysAddr.html +++ b/ch5/os/mm/address/struct.PhysAddr.html @@ -1,45 +1,28 @@ -PhysAddr in os::mm::address - Rust

    Struct os::mm::address::PhysAddr

    source · [−]
    pub struct PhysAddr(pub usize);
    Expand description

    physical address

    -

    Tuple Fields

    0: usize

    Implementations

    PhysAddr->PhysPageNum

    -

    PhysAddr->PhysPageNum

    -

    Get page offset

    -

    Check page aligned

    -

    Get mutable reference to PhysAddr value

    -

    Trait Implementations

    Returns a copy of the value. Read more

    -

    Performs copy-assignment from source. Read more

    -

    Formats the value using the given formatter. Read more

    -

    Converts to this type from the input type.

    -

    Converts to this type from the input type.

    -

    Converts to this type from the input type.

    -

    T: {PhysAddr, VirtAddr, PhysPageNum, VirtPageNum} +PhysAddr in os::mm::address - Rust

    Struct os::mm::address::PhysAddr

    source · 
    pub struct PhysAddr(pub usize);
    Expand description

    physical address

    +

    Tuple Fields§

    §0: usize

    Implementations§

    source§

    impl PhysAddr

    source

    pub fn floor(&self) -> PhysPageNum

    PhysAddr->PhysPageNum

    +
    source

    pub fn ceil(&self) -> PhysPageNum

    PhysAddr->PhysPageNum

    +
    source

    pub fn page_offset(&self) -> usize

    Get page offset

    +
    source

    pub fn aligned(&self) -> bool

    Check page aligned

    +
    source§

    impl PhysAddr

    source

    pub fn get_mut<T>(&self) -> &'static mut T

    Get mutable reference to PhysAddr value

    +

    Trait Implementations§

    source§

    impl Clone for PhysAddr

    source§

    fn clone(&self) -> PhysAddr

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for PhysAddr

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl From<PhysAddr> for PhysPageNum

    source§

    fn from(v: PhysAddr) -> Self

    Converts to this type from the input type.
    source§

    impl From<PhysAddr> for usize

    source§

    fn from(v: PhysAddr) -> Self

    Converts to this type from the input type.
    source§

    impl From<PhysPageNum> for PhysAddr

    source§

    fn from(v: PhysPageNum) -> Self

    Converts to this type from the input type.
    source§

    impl From<usize> for PhysAddr

    T: {PhysAddr, VirtAddr, PhysPageNum, VirtPageNum} T -> usize: T.0 usize -> T: usize.into()

    -

    Converts to this type from the input type.

    -

    This method returns an Ordering between self and other. Read more

    -

    Compares and returns the maximum of two values. Read more

    -

    Compares and returns the minimum of two values. Read more

    -

    Restrict a value to a certain interval. Read more

    -

    This method tests for self and other values to be equal, and is used -by ==. Read more

    -

    This method tests for !=.

    -

    This method returns an ordering between self and other values if one exists. Read more

    -

    This method tests less than (for self and other) and is used by the < operator. Read more

    -

    This method tests less than or equal to (for self and other) and is used by the <= -operator. Read more

    -

    This method tests greater than (for self and other) and is used by the > operator. Read more

    -

    This method tests greater than or equal to (for self and other) and is used by the >= -operator. Read more

    -

    Auto Trait Implementations

    Blanket Implementations

    Gets the TypeId of self. Read more

    -

    Immutably borrows from an owned value. Read more

    -

    Mutably borrows from an owned value. Read more

    -

    Returns the argument unchanged.

    -

    Calls U::from(self).

    +
    source§

    fn from(v: usize) -> Self

    Converts to this type from the input type.
    source§

    impl Ord for PhysAddr

    source§

    fn cmp(&self, other: &PhysAddr) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Selfwhere + Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Selfwhere + Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Selfwhere + Self: Sized + PartialOrd<Self>,

    Restrict a value to a certain interval. Read more
    source§

    impl PartialEq<PhysAddr> for PhysAddr

    source§

    fn eq(&self, other: &PhysAddr) -> bool

    This method tests for self and other values to be equal, and is used +by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always +sufficient, and should not be overridden without very good reason.
    source§

    impl PartialOrd<PhysAddr> for PhysAddr

    source§

    fn partial_cmp(&self, other: &PhysAddr) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    1.0.0 · source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    1.0.0 · source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= +operator. Read more
    1.0.0 · source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    1.0.0 · source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= +operator. Read more
    source§

    impl Copy for PhysAddr

    source§

    impl Eq for PhysAddr

    source§

    impl StructuralEq for PhysAddr

    source§

    impl StructuralPartialEq for PhysAddr

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The resulting type after obtaining ownership.

    -

    Creates owned data from borrowed data, usually by cloning. Read more

    -

    Uses borrowed data to replace owned data, usually by cloning. Read more

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T> ToOwned for Twhere + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/address/struct.PhysPageNum.html b/ch5/os/mm/address/struct.PhysPageNum.html index 81cf94ea..f94a3b79 100644 --- a/ch5/os/mm/address/struct.PhysPageNum.html +++ b/ch5/os/mm/address/struct.PhysPageNum.html @@ -1,38 +1,21 @@ -PhysPageNum in os::mm::address - Rust

    Struct os::mm::address::PhysPageNum

    source · [−]
    pub struct PhysPageNum(pub usize);
    Expand description

    physical page number

    -

    Tuple Fields

    0: usize

    Implementations

    Get PageTableEntry on PhysPageNum

    -

    Trait Implementations

    Returns a copy of the value. Read more

    -

    Performs copy-assignment from source. Read more

    -

    Formats the value using the given formatter. Read more

    -

    Converts to this type from the input type.

    -

    Converts to this type from the input type.

    -

    Converts to this type from the input type.

    -

    Converts to this type from the input type.

    -

    This method returns an Ordering between self and other. Read more

    -

    Compares and returns the maximum of two values. Read more

    -

    Compares and returns the minimum of two values. Read more

    -

    Restrict a value to a certain interval. Read more

    -

    This method tests for self and other values to be equal, and is used -by ==. Read more

    -

    This method tests for !=.

    -

    This method returns an ordering between self and other values if one exists. Read more

    -

    This method tests less than (for self and other) and is used by the < operator. Read more

    -

    This method tests less than or equal to (for self and other) and is used by the <= -operator. Read more

    -

    This method tests greater than (for self and other) and is used by the > operator. Read more

    -

    This method tests greater than or equal to (for self and other) and is used by the >= -operator. Read more

    -

    Auto Trait Implementations

    Blanket Implementations

    Gets the TypeId of self. Read more

    -

    Immutably borrows from an owned value. Read more

    -

    Mutably borrows from an owned value. Read more

    -

    Returns the argument unchanged.

    -

    Calls U::from(self).

    +PhysPageNum in os::mm::address - Rust

    Struct os::mm::address::PhysPageNum

    source · 
    pub struct PhysPageNum(pub usize);
    Expand description

    physical page number

    +

    Tuple Fields§

    §0: usize

    Implementations§

    source§

    impl PhysPageNum

    source

    pub fn get_pte_array(&self) -> &'static mut [PageTableEntry]

    Get PageTableEntry on PhysPageNum

    +
    source

    pub fn get_bytes_array(&self) -> &'static mut [u8]

    source

    pub fn get_mut<T>(&self) -> &'static mut T

    Trait Implementations§

    source§

    impl Clone for PhysPageNum

    source§

    fn clone(&self) -> PhysPageNum

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for PhysPageNum

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl From<PhysAddr> for PhysPageNum

    source§

    fn from(v: PhysAddr) -> Self

    Converts to this type from the input type.
    source§

    impl From<PhysPageNum> for PhysAddr

    source§

    fn from(v: PhysPageNum) -> Self

    Converts to this type from the input type.
    source§

    impl From<PhysPageNum> for usize

    source§

    fn from(v: PhysPageNum) -> Self

    Converts to this type from the input type.
    source§

    impl From<usize> for PhysPageNum

    source§

    fn from(v: usize) -> Self

    Converts to this type from the input type.
    source§

    impl Ord for PhysPageNum

    source§

    fn cmp(&self, other: &PhysPageNum) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Selfwhere + Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Selfwhere + Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Selfwhere + Self: Sized + PartialOrd<Self>,

    Restrict a value to a certain interval. Read more
    source§

    impl PartialEq<PhysPageNum> for PhysPageNum

    source§

    fn eq(&self, other: &PhysPageNum) -> bool

    This method tests for self and other values to be equal, and is used +by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always +sufficient, and should not be overridden without very good reason.
    source§

    impl PartialOrd<PhysPageNum> for PhysPageNum

    source§

    fn partial_cmp(&self, other: &PhysPageNum) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    1.0.0 · source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    1.0.0 · source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= +operator. Read more
    1.0.0 · source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    1.0.0 · source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= +operator. Read more
    source§

    impl Copy for PhysPageNum

    source§

    impl Eq for PhysPageNum

    source§

    impl StructuralEq for PhysPageNum

    source§

    impl StructuralPartialEq for PhysPageNum

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The resulting type after obtaining ownership.

    -

    Creates owned data from borrowed data, usually by cloning. Read more

    -

    Uses borrowed data to replace owned data, usually by cloning. Read more

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T> ToOwned for Twhere + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/address/struct.SimpleRange.html b/ch5/os/mm/address/struct.SimpleRange.html index 149264e1..76a20c20 100644 --- a/ch5/os/mm/address/struct.SimpleRange.html +++ b/ch5/os/mm/address/struct.SimpleRange.html @@ -1,24 +1,26 @@ -SimpleRange in os::mm::address - Rust

    Struct os::mm::address::SimpleRange

    source · [−]
    pub struct SimpleRange<T> where
        T: StepByOne + Copy + PartialEq + PartialOrd + Debug,     {
+SimpleRange in os::mm::address - Rust
    Struct os::mm::address::SimpleRange
    source · 
    pub struct SimpleRange<T>where
+    T: StepByOne + Copy + PartialEq + PartialOrd + Debug,{
     l: T,
     r: T,
-}
    Expand description
    a simple range structure for type T
    
-
    Fields
    l: Tr: T
    Implementations
    Trait Implementations
    Returns a copy of the value. Read more
    
-
    Performs copy-assignment from source. Read more
    
-
    The type of the elements being iterated over.
    
-
    Which kind of iterator are we turning this into?
    
-
    Creates an iterator from a value. Read more
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}
    Expand description

    a simple range structure for type T

    +

    Fields§

    §l: T§r: T

    Implementations§

    source§

    impl<T> SimpleRange<T>where + T: StepByOne + Copy + PartialEq + PartialOrd + Debug,

    source

    pub fn new(start: T, end: T) -> Self

    source

    pub fn get_start(&self) -> T

    source

    pub fn get_end(&self) -> T

    Trait Implementations§

    source§

    impl<T> Clone for SimpleRange<T>where + T: StepByOne + Copy + PartialEq + PartialOrd + Debug + Clone,

    source§

    fn clone(&self) -> SimpleRange<T>

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<T> IntoIterator for SimpleRange<T>where + T: StepByOne + Copy + PartialEq + PartialOrd + Debug,

    §

    type Item = T

    The type of the elements being iterated over.
    §

    type IntoIter = SimpleRangeIterator<T>

    Which kind of iterator are we turning this into?
    source§

    fn into_iter(self) -> Self::IntoIter

    Creates an iterator from a value. Read more
    source§

    impl<T> Copy for SimpleRange<T>where + T: StepByOne + Copy + PartialEq + PartialOrd + Debug + Copy,

    Auto Trait Implementations§

    §

    impl<T> RefUnwindSafe for SimpleRange<T>where + T: RefUnwindSafe,

    §

    impl<T> Send for SimpleRange<T>where + T: Send,

    §

    impl<T> Sync for SimpleRange<T>where + T: Sync,

    §

    impl<T> Unpin for SimpleRange<T>where + T: Unpin,

    §

    impl<T> UnwindSafe for SimpleRange<T>where + T: UnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The resulting type after obtaining ownership.

    -

    Creates owned data from borrowed data, usually by cloning. Read more

    -

    Uses borrowed data to replace owned data, usually by cloning. Read more

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T> ToOwned for Twhere + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/address/struct.SimpleRangeIterator.html b/ch5/os/mm/address/struct.SimpleRangeIterator.html index 6d685cb5..e31164ea 100644 --- a/ch5/os/mm/address/struct.SimpleRangeIterator.html +++ b/ch5/os/mm/address/struct.SimpleRangeIterator.html @@ -1,132 +1,201 @@ -SimpleRangeIterator in os::mm::address - Rust

    Struct os::mm::address::SimpleRangeIterator

    source · [−]
    pub struct SimpleRangeIterator<T> where
        T: StepByOne + Copy + PartialEq + PartialOrd + Debug,     {
+SimpleRangeIterator in os::mm::address - Rust
    Struct os::mm::address::SimpleRangeIterator
    source · 
    pub struct SimpleRangeIterator<T>where
+    T: StepByOne + Copy + PartialEq + PartialOrd + Debug,{
     current: T,
     end: T,
-}
    Expand description
    iterator for the simple range structure
    
-
    Fields
    current: Tend: T
    Implementations
    Trait Implementations
    The type of the elements being iterated over.
    
-
    Advances the iterator and returns the next value. Read more
    
-
    🔬 This is a nightly-only experimental API. (iter_next_chunk)
    Advances the iterator and returns an array containing the next N values. Read more
    
-
    Returns the bounds on the remaining length of the iterator. Read more
    
-
    Consumes the iterator, counting the number of iterations and returning it. Read more
    
-
    Consumes the iterator, returning the last element. Read more
    
-
    🔬 This is a nightly-only experimental API. (iter_advance_by)
    Advances the iterator by n elements. Read more
    
-
    Returns the nth element of the iterator. Read more
    
-
    Creates an iterator starting at the same point, but stepping by
-the given amount at each iteration. Read more
    
-
    Takes two iterators and creates a new iterator over both in sequence. Read more
    
-
    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    
-
    🔬 This is a nightly-only experimental API. (iter_intersperse)
    Creates a new iterator which places a copy of separator between adjacent
-items of the original iterator. Read more
    
-
    🔬 This is a nightly-only experimental API. (iter_intersperse)
    Creates a new iterator which places an item generated by separator
-between adjacent items of the original iterator. Read more
    
-
    Takes a closure and creates an iterator which calls that closure on each
-element. Read more
    
-
    Calls a closure on each element of an iterator. Read more
    
-
    Creates an iterator which uses a closure to determine if an element
-should be yielded. Read more
    
-
    Creates an iterator that both filters and maps. Read more
    
-
    Creates an iterator which gives the current iteration count as well as
-the next value. Read more
    
-
    Creates an iterator which can use the peek and peek_mut methods
+}
    Expand description

    iterator for the simple range structure

    +

    Fields§

    §current: T§end: T

    Implementations§

    source§

    impl<T> SimpleRangeIterator<T>where + T: StepByOne + Copy + PartialEq + PartialOrd + Debug,

    source

    pub fn new(l: T, r: T) -> Self

    Trait Implementations§

    source§

    impl<T> Iterator for SimpleRangeIterator<T>where + T: StepByOne + Copy + PartialEq + PartialOrd + Debug,

    §

    type Item = T

    The type of the elements being iterated over.
    source§

    fn next(&mut self) -> Option<Self::Item>

    Advances the iterator and returns the next value. Read more
    source§

    fn next_chunk<const N: usize>( + &mut self +) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_next_chunk)
    Advances the iterator and returns an array containing the next N values. Read more
    1.0.0 · source§

    fn size_hint(&self) -> (usize, Option<usize>)

    Returns the bounds on the remaining length of the iterator. Read more
    1.0.0 · source§

    fn count(self) -> usizewhere + Self: Sized,

    Consumes the iterator, counting the number of iterations and returning it. Read more
    1.0.0 · source§

    fn last(self) -> Option<Self::Item>where + Self: Sized,

    Consumes the iterator, returning the last element. Read more
    source§

    fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize>

    🔬This is a nightly-only experimental API. (iter_advance_by)
    Advances the iterator by n elements. Read more
    1.0.0 · source§

    fn nth(&mut self, n: usize) -> Option<Self::Item>

    Returns the nth element of the iterator. Read more
    1.28.0 · source§

    fn step_by(self, step: usize) -> StepBy<Self>where + Self: Sized,

    Creates an iterator starting at the same point, but stepping by +the given amount at each iteration. Read more
    1.0.0 · source§

    fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where + Self: Sized, + U: IntoIterator<Item = Self::Item>,

    Takes two iterators and creates a new iterator over both in sequence. Read more
    1.0.0 · source§

    fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where + Self: Sized, + U: IntoIterator,

    ‘Zips up’ two iterators into a single iterator of pairs. Read more
    source§

    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>where + Self: Sized, + G: FnMut() -> Self::Item,

    🔬This is a nightly-only experimental API. (iter_intersperse)
    Creates a new iterator which places an item generated by separator +between adjacent items of the original iterator. Read more
    1.0.0 · source§

    fn map<B, F>(self, f: F) -> Map<Self, F>where + Self: Sized, + F: FnMut(Self::Item) -> B,

    Takes a closure and creates an iterator which calls that closure on each +element. Read more
    1.21.0 · source§

    fn for_each<F>(self, f: F)where + Self: Sized, + F: FnMut(Self::Item),

    Calls a closure on each element of an iterator. Read more
    1.0.0 · source§

    fn filter<P>(self, predicate: P) -> Filter<Self, P>where + Self: Sized, + P: FnMut(&Self::Item) -> bool,

    Creates an iterator which uses a closure to determine if an element +should be yielded. Read more
    1.0.0 · source§

    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where + Self: Sized, + F: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both filters and maps. Read more
    1.0.0 · source§

    fn enumerate(self) -> Enumerate<Self>where + Self: Sized,

    Creates an iterator which gives the current iteration count as well as +the next value. Read more
    1.0.0 · source§

    fn peekable(self) -> Peekable<Self>where + Self: Sized,

    Creates an iterator which can use the peek and peek_mut methods to look at the next element of the iterator without consuming it. See -their documentation for more information. Read more

    -

    Creates an iterator that skips elements based on a predicate. Read more

    -

    Creates an iterator that yields elements based on a predicate. Read more

    -

    Creates an iterator that both yields elements based on a predicate and maps. Read more

    -

    Creates an iterator that skips the first n elements. Read more

    -

    Creates an iterator that yields the first n elements, or fewer -if the underlying iterator ends sooner. Read more

    -

    An iterator adapter similar to fold that holds internal state and -produces a new iterator. Read more

    -

    Creates an iterator that works like map, but flattens nested structure. Read more

    -

    Creates an iterator that flattens nested structure. Read more

    -

    Creates an iterator which ends after the first None. Read more

    -

    Does something with each element of an iterator, passing the value on. Read more

    -

    Borrows an iterator, rather than consuming it. Read more

    -

    Transforms an iterator into a collection. Read more

    -
    🔬 This is a nightly-only experimental API. (iterator_try_collect)

    Fallibly transforms an iterator into a collection, short circuiting if -a failure is encountered. Read more

    -
    🔬 This is a nightly-only experimental API. (iter_collect_into)

    Collects all the items from an iterator into a collection. Read more

    -

    Consumes an iterator, creating two collections from it. Read more

    -
    🔬 This is a nightly-only experimental API. (iter_partition_in_place)

    Reorders the elements of this iterator in-place according to the given predicate, -such that all those that return true precede all those that return false. -Returns the number of true elements found. Read more

    -
    🔬 This is a nightly-only experimental API. (iter_is_partitioned)

    Checks if the elements of this iterator are partitioned according to the given predicate, -such that all those that return true precede all those that return false. Read more

    -

    An iterator method that applies a function as long as it returns -successfully, producing a single, final value. Read more

    -

    An iterator method that applies a fallible function to each item in the -iterator, stopping at the first error and returning that error. Read more

    -

    Folds every element into an accumulator by applying an operation, -returning the final result. Read more

    -

    Reduces the elements to a single one, by repeatedly applying a reducing -operation. Read more

    -
    🔬 This is a nightly-only experimental API. (iterator_try_reduce)

    Reduces the elements to a single one by repeatedly applying a reducing operation. If the -closure returns a failure, the failure is propagated back to the caller immediately. Read more

    -

    Tests if every element of the iterator matches a predicate. Read more

    -

    Tests if any element of the iterator matches a predicate. Read more

    -

    Searches for an element of an iterator that satisfies a predicate. Read more

    -

    Applies function to the elements of iterator and returns -the first non-none result. Read more

    -
    🔬 This is a nightly-only experimental API. (try_find)

    Applies function to the elements of iterator and returns -the first true result or the first error. Read more

    -

    Searches for an element in an iterator, returning its index. Read more

    -

    Searches for an element in an iterator from the right, returning its -index. Read more

    -

    Returns the maximum element of an iterator. Read more

    -

    Returns the minimum element of an iterator. Read more

    -

    Returns the element that gives the maximum value from the -specified function. Read more

    -

    Returns the element that gives the maximum value with respect to the -specified comparison function. Read more

    -

    Returns the element that gives the minimum value from the -specified function. Read more

    -

    Returns the element that gives the minimum value with respect to the -specified comparison function. Read more

    -

    Reverses an iterator’s direction. Read more

    -

    Converts an iterator of pairs into a pair of containers. Read more

    -

    Creates an iterator which copies all of its elements. Read more

    -

    Creates an iterator which clones all of its elements. Read more

    -

    Repeats an iterator endlessly. Read more

    -

    Sums the elements of an iterator. Read more

    -

    Iterates over the entire iterator, multiplying all the elements Read more

    -

    Lexicographically compares the elements of this Iterator with those -of another. Read more

    -
    🔬 This is a nightly-only experimental API. (iter_order_by)

    Lexicographically compares the elements of this Iterator with those -of another with respect to the specified comparison function. Read more

    -

    Lexicographically compares the elements of this Iterator with those -of another. Read more

    -
    🔬 This is a nightly-only experimental API. (iter_order_by)

    Lexicographically compares the elements of this Iterator with those -of another with respect to the specified comparison function. Read more

    -

    Determines if the elements of this Iterator are equal to those of -another. Read more

    -
    🔬 This is a nightly-only experimental API. (iter_order_by)

    Determines if the elements of this Iterator are equal to those of -another with respect to the specified equality function. Read more

    -

    Determines if the elements of this Iterator are unequal to those of -another. Read more

    -

    Determines if the elements of this Iterator are lexicographically -less than those of another. Read more

    -

    Determines if the elements of this Iterator are lexicographically -less or equal to those of another. Read more

    -

    Determines if the elements of this Iterator are lexicographically -greater than those of another. Read more

    -

    Determines if the elements of this Iterator are lexicographically -greater than or equal to those of another. Read more

    -
    🔬 This is a nightly-only experimental API. (is_sorted)

    Checks if the elements of this iterator are sorted. Read more

    -
    🔬 This is a nightly-only experimental API. (is_sorted)

    Checks if the elements of this iterator are sorted using the given comparator function. Read more

    -
    🔬 This is a nightly-only experimental API. (is_sorted)

    Checks if the elements of this iterator are sorted using the given key extraction -function. Read more

    -

    Auto Trait Implementations

    Blanket Implementations

    Gets the TypeId of self. Read more

    -

    Immutably borrows from an owned value. Read more

    -

    Mutably borrows from an owned value. Read more

    -

    Returns the argument unchanged.

    -

    Calls U::from(self).

    +their documentation for more information. Read more
    1.0.0 · source§

    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where + Self: Sized, + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that skips elements based on a predicate. Read more
    1.0.0 · source§

    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where + Self: Sized, + P: FnMut(&Self::Item) -> bool,

    Creates an iterator that yields elements based on a predicate. Read more
    1.57.0 · source§

    fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where + Self: Sized, + P: FnMut(Self::Item) -> Option<B>,

    Creates an iterator that both yields elements based on a predicate and maps. Read more
    1.0.0 · source§

    fn skip(self, n: usize) -> Skip<Self>where + Self: Sized,

    Creates an iterator that skips the first n elements. Read more
    1.0.0 · source§

    fn take(self, n: usize) -> Take<Self>where + Self: Sized,

    Creates an iterator that yields the first n elements, or fewer +if the underlying iterator ends sooner. Read more
    1.0.0 · source§

    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where + Self: Sized, + F: FnMut(&mut St, Self::Item) -> Option<B>,

    An iterator adapter which, like fold, holds internal state, but +unlike fold, produces a new iterator. Read more
    1.0.0 · source§

    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where + Self: Sized, + U: IntoIterator, + F: FnMut(Self::Item) -> U,

    Creates an iterator that works like map, but flattens nested structure. Read more
    source§

    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>where + Self: Sized, + F: FnMut(&[Self::Item; N]) -> R,

    🔬This is a nightly-only experimental API. (iter_map_windows)
    Calls the given function f for each contiguous window of size N over +self and returns an iterator over the outputs of f. Like slice::windows(), +the windows during mapping overlap as well. Read more
    1.0.0 · source§

    fn fuse(self) -> Fuse<Self>where + Self: Sized,

    Creates an iterator which ends after the first None. Read more
    1.0.0 · source§

    fn inspect<F>(self, f: F) -> Inspect<Self, F>where + Self: Sized, + F: FnMut(&Self::Item),

    Does something with each element of an iterator, passing the value on. Read more
    1.0.0 · source§

    fn by_ref(&mut self) -> &mut Selfwhere + Self: Sized,

    Borrows an iterator, rather than consuming it. Read more
    1.0.0 · source§

    fn collect<B>(self) -> Bwhere + B: FromIterator<Self::Item>, + Self: Sized,

    Transforms an iterator into a collection. Read more
    source§

    fn collect_into<E>(self, collection: &mut E) -> &mut Ewhere + E: Extend<Self::Item>, + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_collect_into)
    Collects all the items from an iterator into a collection. Read more
    1.0.0 · source§

    fn partition<B, F>(self, f: F) -> (B, B)where + Self: Sized, + B: Default + Extend<Self::Item>, + F: FnMut(&Self::Item) -> bool,

    Consumes an iterator, creating two collections from it. Read more
    source§

    fn is_partitioned<P>(self, predicate: P) -> boolwhere + Self: Sized, + P: FnMut(Self::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_is_partitioned)
    Checks if the elements of this iterator are partitioned according to the given predicate, +such that all those that return true precede all those that return false. Read more
    1.27.0 · source§

    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere + Self: Sized, + F: FnMut(B, Self::Item) -> R, + R: Try<Output = B>,

    An iterator method that applies a function as long as it returns +successfully, producing a single, final value. Read more
    1.27.0 · source§

    fn try_for_each<F, R>(&mut self, f: F) -> Rwhere + Self: Sized, + F: FnMut(Self::Item) -> R, + R: Try<Output = ()>,

    An iterator method that applies a fallible function to each item in the +iterator, stopping at the first error and returning that error. Read more
    1.0.0 · source§

    fn fold<B, F>(self, init: B, f: F) -> Bwhere + Self: Sized, + F: FnMut(B, Self::Item) -> B,

    Folds every element into an accumulator by applying an operation, +returning the final result. Read more
    1.51.0 · source§

    fn reduce<F>(self, f: F) -> Option<Self::Item>where + Self: Sized, + F: FnMut(Self::Item, Self::Item) -> Self::Item,

    Reduces the elements to a single one, by repeatedly applying a reducing +operation. Read more
    source§

    fn try_reduce<F, R>( + &mut self, + f: F +) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryTypewhere + Self: Sized, + F: FnMut(Self::Item, Self::Item) -> R, + R: Try<Output = Self::Item>, + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (iterator_try_reduce)
    Reduces the elements to a single one by repeatedly applying a reducing operation. If the +closure returns a failure, the failure is propagated back to the caller immediately. Read more
    1.0.0 · source§

    fn all<F>(&mut self, f: F) -> boolwhere + Self: Sized, + F: FnMut(Self::Item) -> bool,

    Tests if every element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn any<F>(&mut self, f: F) -> boolwhere + Self: Sized, + F: FnMut(Self::Item) -> bool,

    Tests if any element of the iterator matches a predicate. Read more
    1.0.0 · source§

    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>where + Self: Sized, + P: FnMut(&Self::Item) -> bool,

    Searches for an element of an iterator that satisfies a predicate. Read more
    1.30.0 · source§

    fn find_map<B, F>(&mut self, f: F) -> Option<B>where + Self: Sized, + F: FnMut(Self::Item) -> Option<B>,

    Applies function to the elements of iterator and returns +the first non-none result. Read more
    source§

    fn try_find<F, R>( + &mut self, + f: F +) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere + Self: Sized, + F: FnMut(&Self::Item) -> R, + R: Try<Output = bool>, + <R as Try>::Residual: Residual<Option<Self::Item>>,

    🔬This is a nightly-only experimental API. (try_find)
    Applies function to the elements of iterator and returns +the first true result or the first error. Read more
    1.0.0 · source§

    fn position<P>(&mut self, predicate: P) -> Option<usize>where + Self: Sized, + P: FnMut(Self::Item) -> bool,

    Searches for an element in an iterator, returning its index. Read more
    1.6.0 · source§

    fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where + B: Ord, + Self: Sized, + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the maximum value from the +specified function. Read more
    1.15.0 · source§

    fn max_by<F>(self, compare: F) -> Option<Self::Item>where + Self: Sized, + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the maximum value with respect to the +specified comparison function. Read more
    1.6.0 · source§

    fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where + B: Ord, + Self: Sized, + F: FnMut(&Self::Item) -> B,

    Returns the element that gives the minimum value from the +specified function. Read more
    1.15.0 · source§

    fn min_by<F>(self, compare: F) -> Option<Self::Item>where + Self: Sized, + F: FnMut(&Self::Item, &Self::Item) -> Ordering,

    Returns the element that gives the minimum value with respect to the +specified comparison function. Read more
    1.0.0 · source§

    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where + FromA: Default + Extend<A>, + FromB: Default + Extend<B>, + Self: Sized + Iterator<Item = (A, B)>,

    Converts an iterator of pairs into a pair of containers. Read more
    1.36.0 · source§

    fn copied<'a, T>(self) -> Copied<Self>where + T: 'a + Copy, + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which copies all of its elements. Read more
    1.0.0 · source§

    fn cloned<'a, T>(self) -> Cloned<Self>where + T: 'a + Clone, + Self: Sized + Iterator<Item = &'a T>,

    Creates an iterator which clones all of its elements. Read more
    source§

    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where + Self: Sized,

    🔬This is a nightly-only experimental API. (iter_array_chunks)
    Returns an iterator over N elements of the iterator at a time. Read more
    1.11.0 · source§

    fn sum<S>(self) -> Swhere + Self: Sized, + S: Sum<Self::Item>,

    Sums the elements of an iterator. Read more
    1.11.0 · source§

    fn product<P>(self) -> Pwhere + Self: Sized, + P: Product<Self::Item>,

    Iterates over the entire iterator, multiplying all the elements Read more
    source§

    fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere + Self: Sized, + I: IntoIterator, + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

    🔬This is a nightly-only experimental API. (iter_order_by)
    Lexicographically compares the elements of this Iterator with those +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn partial_cmp<I>(self, other: I) -> Option<Ordering>where + I: IntoIterator, + Self::Item: PartialOrd<<I as IntoIterator>::Item>, + Self: Sized,

    Lexicographically compares the PartialOrd elements of +this Iterator with those of another. The comparison works like short-circuit +evaluation, returning a result without comparing the remaining elements. +As soon as an order can be determined, the evaluation stops and a result is returned. Read more
    source§

    fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where + Self: Sized, + I: IntoIterator, + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (iter_order_by)
    Lexicographically compares the elements of this Iterator with those +of another with respect to the specified comparison function. Read more
    1.5.0 · source§

    fn eq<I>(self, other: I) -> boolwhere + I: IntoIterator, + Self::Item: PartialEq<<I as IntoIterator>::Item>, + Self: Sized,

    Determines if the elements of this Iterator are equal to those of +another. Read more
    source§

    fn eq_by<I, F>(self, other: I, eq: F) -> boolwhere + Self: Sized, + I: IntoIterator, + F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

    🔬This is a nightly-only experimental API. (iter_order_by)
    Determines if the elements of this Iterator are equal to those of +another with respect to the specified equality function. Read more
    1.5.0 · source§

    fn ne<I>(self, other: I) -> boolwhere + I: IntoIterator, + Self::Item: PartialEq<<I as IntoIterator>::Item>, + Self: Sized,

    Determines if the elements of this Iterator are not equal to those of +another. Read more
    1.5.0 · source§

    fn lt<I>(self, other: I) -> boolwhere + I: IntoIterator, + Self::Item: PartialOrd<<I as IntoIterator>::Item>, + Self: Sized,

    Determines if the elements of this Iterator are lexicographically +less than those of another. Read more
    1.5.0 · source§

    fn le<I>(self, other: I) -> boolwhere + I: IntoIterator, + Self::Item: PartialOrd<<I as IntoIterator>::Item>, + Self: Sized,

    Determines if the elements of this Iterator are lexicographically +less or equal to those of another. Read more
    1.5.0 · source§

    fn gt<I>(self, other: I) -> boolwhere + I: IntoIterator, + Self::Item: PartialOrd<<I as IntoIterator>::Item>, + Self: Sized,

    Determines if the elements of this Iterator are lexicographically +greater than those of another. Read more
    1.5.0 · source§

    fn ge<I>(self, other: I) -> boolwhere + I: IntoIterator, + Self::Item: PartialOrd<<I as IntoIterator>::Item>, + Self: Sized,

    Determines if the elements of this Iterator are lexicographically +greater than or equal to those of another. Read more
    source§

    fn is_sorted_by<F>(self, compare: F) -> boolwhere + Self: Sized, + F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,

    🔬This is a nightly-only experimental API. (is_sorted)
    Checks if the elements of this iterator are sorted using the given comparator function. Read more
    source§

    fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere + Self: Sized, + F: FnMut(Self::Item) -> K, + K: PartialOrd<K>,

    🔬This is a nightly-only experimental API. (is_sorted)
    Checks if the elements of this iterator are sorted using the given key extraction +function. Read more

    Auto Trait Implementations§

    §

    impl<T> RefUnwindSafe for SimpleRangeIterator<T>where + T: RefUnwindSafe,

    §

    impl<T> Send for SimpleRangeIterator<T>where + T: Send,

    §

    impl<T> Sync for SimpleRangeIterator<T>where + T: Sync,

    §

    impl<T> Unpin for SimpleRangeIterator<T>where + T: Unpin,

    §

    impl<T> UnwindSafe for SimpleRangeIterator<T>where + T: UnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type of the elements being iterated over.

    -

    Which kind of iterator are we turning this into?

    -

    Creates an iterator from a value. Read more

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<I> IntoIterator for Iwhere + I: Iterator,

    §

    type Item = <I as Iterator>::Item

    The type of the elements being iterated over.
    §

    type IntoIter = I

    Which kind of iterator are we turning this into?
    const: unstable · source§

    fn into_iter(self) -> I

    Creates an iterator from a value. Read more
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/address/struct.VirtAddr.html b/ch5/os/mm/address/struct.VirtAddr.html index 89b47417..ca4158f8 100644 --- a/ch5/os/mm/address/struct.VirtAddr.html +++ b/ch5/os/mm/address/struct.VirtAddr.html @@ -1,42 +1,25 @@ -VirtAddr in os::mm::address - Rust

    Struct os::mm::address::VirtAddr

    source · [−]
    pub struct VirtAddr(pub usize);
    Expand description

    virtual address

    -

    Tuple Fields

    0: usize

    Implementations

    VirtAddr->VirtPageNum

    -

    VirtAddr->VirtPageNum

    -

    Get page offset

    -

    Check page aligned

    -

    Trait Implementations

    Returns a copy of the value. Read more

    -

    Performs copy-assignment from source. Read more

    -

    Debugging

    -

    Formats the value using the given formatter. Read more

    -

    Converts to this type from the input type.

    -

    Converts to this type from the input type.

    -

    Converts to this type from the input type.

    -

    Converts to this type from the input type.

    -

    This method returns an Ordering between self and other. Read more

    -

    Compares and returns the maximum of two values. Read more

    -

    Compares and returns the minimum of two values. Read more

    -

    Restrict a value to a certain interval. Read more

    -

    This method tests for self and other values to be equal, and is used -by ==. Read more

    -

    This method tests for !=.

    -

    This method returns an ordering between self and other values if one exists. Read more

    -

    This method tests less than (for self and other) and is used by the < operator. Read more

    -

    This method tests less than or equal to (for self and other) and is used by the <= -operator. Read more

    -

    This method tests greater than (for self and other) and is used by the > operator. Read more

    -

    This method tests greater than or equal to (for self and other) and is used by the >= -operator. Read more

    -

    Auto Trait Implementations

    Blanket Implementations

    Gets the TypeId of self. Read more

    -

    Immutably borrows from an owned value. Read more

    -

    Mutably borrows from an owned value. Read more

    -

    Returns the argument unchanged.

    -

    Calls U::from(self).

    +VirtAddr in os::mm::address - Rust

    Struct os::mm::address::VirtAddr

    source · 
    pub struct VirtAddr(pub usize);
    Expand description

    virtual address

    +

    Tuple Fields§

    §0: usize

    Implementations§

    source§

    impl VirtAddr

    source

    pub fn floor(&self) -> VirtPageNum

    VirtAddr->VirtPageNum

    +
    source

    pub fn ceil(&self) -> VirtPageNum

    VirtAddr->VirtPageNum

    +
    source

    pub fn page_offset(&self) -> usize

    Get page offset

    +
    source

    pub fn aligned(&self) -> bool

    Check page aligned

    +

    Trait Implementations§

    source§

    impl Clone for VirtAddr

    source§

    fn clone(&self) -> VirtAddr

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for VirtAddr

    Debugging

    +
    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl From<VirtAddr> for VirtPageNum

    source§

    fn from(v: VirtAddr) -> Self

    Converts to this type from the input type.
    source§

    impl From<VirtAddr> for usize

    source§

    fn from(v: VirtAddr) -> Self

    Converts to this type from the input type.
    source§

    impl From<VirtPageNum> for VirtAddr

    source§

    fn from(v: VirtPageNum) -> Self

    Converts to this type from the input type.
    source§

    impl From<usize> for VirtAddr

    source§

    fn from(v: usize) -> Self

    Converts to this type from the input type.
    source§

    impl Ord for VirtAddr

    source§

    fn cmp(&self, other: &VirtAddr) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Selfwhere + Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Selfwhere + Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Selfwhere + Self: Sized + PartialOrd<Self>,

    Restrict a value to a certain interval. Read more
    source§

    impl PartialEq<VirtAddr> for VirtAddr

    source§

    fn eq(&self, other: &VirtAddr) -> bool

    This method tests for self and other values to be equal, and is used +by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always +sufficient, and should not be overridden without very good reason.
    source§

    impl PartialOrd<VirtAddr> for VirtAddr

    source§

    fn partial_cmp(&self, other: &VirtAddr) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    1.0.0 · source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    1.0.0 · source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= +operator. Read more
    1.0.0 · source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    1.0.0 · source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= +operator. Read more
    source§

    impl Copy for VirtAddr

    source§

    impl Eq for VirtAddr

    source§

    impl StructuralEq for VirtAddr

    source§

    impl StructuralPartialEq for VirtAddr

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The resulting type after obtaining ownership.

    -

    Creates owned data from borrowed data, usually by cloning. Read more

    -

    Uses borrowed data to replace owned data, usually by cloning. Read more

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T> ToOwned for Twhere + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/address/struct.VirtPageNum.html b/ch5/os/mm/address/struct.VirtPageNum.html index cb7be603..55e6f75e 100644 --- a/ch5/os/mm/address/struct.VirtPageNum.html +++ b/ch5/os/mm/address/struct.VirtPageNum.html @@ -1,38 +1,21 @@ -VirtPageNum in os::mm::address - Rust

    Struct os::mm::address::VirtPageNum

    source · [−]
    pub struct VirtPageNum(pub usize);
    Expand description

    virtual page number

    -

    Tuple Fields

    0: usize

    Implementations

    Return VPN 3 level index

    -

    Trait Implementations

    Returns a copy of the value. Read more

    -

    Performs copy-assignment from source. Read more

    -

    Formats the value using the given formatter. Read more

    -

    Converts to this type from the input type.

    -

    Converts to this type from the input type.

    -

    Converts to this type from the input type.

    -

    Converts to this type from the input type.

    -

    This method returns an Ordering between self and other. Read more

    -

    Compares and returns the maximum of two values. Read more

    -

    Compares and returns the minimum of two values. Read more

    -

    Restrict a value to a certain interval. Read more

    -

    This method tests for self and other values to be equal, and is used -by ==. Read more

    -

    This method tests for !=.

    -

    This method returns an ordering between self and other values if one exists. Read more

    -

    This method tests less than (for self and other) and is used by the < operator. Read more

    -

    This method tests less than or equal to (for self and other) and is used by the <= -operator. Read more

    -

    This method tests greater than (for self and other) and is used by the > operator. Read more

    -

    This method tests greater than or equal to (for self and other) and is used by the >= -operator. Read more

    -

    Auto Trait Implementations

    Blanket Implementations

    Gets the TypeId of self. Read more

    -

    Immutably borrows from an owned value. Read more

    -

    Mutably borrows from an owned value. Read more

    -

    Returns the argument unchanged.

    -

    Calls U::from(self).

    +VirtPageNum in os::mm::address - Rust

    Struct os::mm::address::VirtPageNum

    source · 
    pub struct VirtPageNum(pub usize);
    Expand description

    virtual page number

    +

    Tuple Fields§

    §0: usize

    Implementations§

    source§

    impl VirtPageNum

    source

    pub fn indexes(&self) -> [usize; 3]

    Return VPN 3 level index

    +

    Trait Implementations§

    source§

    impl Clone for VirtPageNum

    source§

    fn clone(&self) -> VirtPageNum

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for VirtPageNum

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl From<VirtAddr> for VirtPageNum

    source§

    fn from(v: VirtAddr) -> Self

    Converts to this type from the input type.
    source§

    impl From<VirtPageNum> for VirtAddr

    source§

    fn from(v: VirtPageNum) -> Self

    Converts to this type from the input type.
    source§

    impl From<VirtPageNum> for usize

    source§

    fn from(v: VirtPageNum) -> Self

    Converts to this type from the input type.
    source§

    impl From<usize> for VirtPageNum

    source§

    fn from(v: usize) -> Self

    Converts to this type from the input type.
    source§

    impl Ord for VirtPageNum

    source§

    fn cmp(&self, other: &VirtPageNum) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Selfwhere + Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Selfwhere + Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Selfwhere + Self: Sized + PartialOrd<Self>,

    Restrict a value to a certain interval. Read more
    source§

    impl PartialEq<VirtPageNum> for VirtPageNum

    source§

    fn eq(&self, other: &VirtPageNum) -> bool

    This method tests for self and other values to be equal, and is used +by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always +sufficient, and should not be overridden without very good reason.
    source§

    impl PartialOrd<VirtPageNum> for VirtPageNum

    source§

    fn partial_cmp(&self, other: &VirtPageNum) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    1.0.0 · source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    1.0.0 · source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= +operator. Read more
    1.0.0 · source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    1.0.0 · source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= +operator. Read more
    source§

    impl StepByOne for VirtPageNum

    source§

    fn step(&mut self)

    source§

    impl Copy for VirtPageNum

    source§

    impl Eq for VirtPageNum

    source§

    impl StructuralEq for VirtPageNum

    source§

    impl StructuralPartialEq for VirtPageNum

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The resulting type after obtaining ownership.

    -

    Creates owned data from borrowed data, usually by cloning. Read more

    -

    Uses borrowed data to replace owned data, usually by cloning. Read more

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T> ToOwned for Twhere + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/address/trait.StepByOne.html b/ch5/os/mm/address/trait.StepByOne.html index 4d0a6b8a..17274594 100644 --- a/ch5/os/mm/address/trait.StepByOne.html +++ b/ch5/os/mm/address/trait.StepByOne.html @@ -1,3 +1,4 @@ -StepByOne in os::mm::address - Rust

    Trait os::mm::address::StepByOne

    source · [−]
    pub trait StepByOne {
-    fn step(&mut self);
-}

    Required Methods

    Implementors

    \ No newline at end of file +StepByOne in os::mm::address - Rust

    Trait os::mm::address::StepByOne

    source · 
    pub trait StepByOne {
+    // Required method
+    fn step(&mut self);
+}

    Required Methods§

    source

    fn step(&mut self)

    Implementors§

    \ No newline at end of file diff --git a/ch5/os/mm/address/type.VPNRange.html b/ch5/os/mm/address/type.VPNRange.html index 4c732695..375df987 100644 --- a/ch5/os/mm/address/type.VPNRange.html +++ b/ch5/os/mm/address/type.VPNRange.html @@ -1,2 +1,9 @@ -VPNRange in os::mm::address - Rust

    Type Definition os::mm::address::VPNRange

    source · [−]
    pub type VPNRange = SimpleRange<VirtPageNum>;
    Expand description

    a simple range structure for virtual page number

    -
    \ No newline at end of file +VPNRange in os::mm::address - Rust

    Type Alias os::mm::address::VPNRange

    source · 
    pub type VPNRange = SimpleRange<VirtPageNum>;
    Expand description

    a simple range structure for virtual page number

    +

    Aliased Type§

    struct VPNRange {
+    l: VirtPageNum,
+    r: VirtPageNum,
+}

    Fields§

    §l: VirtPageNum§r: VirtPageNum

    Implementations§

    source§

    impl<T> SimpleRange<T>where + T: StepByOne + Copy + PartialEq + PartialOrd + Debug,

    source

    pub fn new(start: T, end: T) -> Self

    source

    pub fn get_start(&self) -> T

    source

    pub fn get_end(&self) -> T

    Trait Implementations§

    source§

    impl<T> Clone for SimpleRange<T>where + T: StepByOne + Copy + PartialEq + PartialOrd + Debug + Clone,

    source§

    fn clone(&self) -> SimpleRange<T>

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl<T> IntoIterator for SimpleRange<T>where + T: StepByOne + Copy + PartialEq + PartialOrd + Debug,

    §

    type Item = T

    The type of the elements being iterated over.
    §

    type IntoIter = SimpleRangeIterator<T>

    Which kind of iterator are we turning this into?
    source§

    fn into_iter(self) -> Self::IntoIter

    Creates an iterator from a value. Read more
    source§

    impl<T> Copy for SimpleRange<T>where + T: StepByOne + Copy + PartialEq + PartialOrd + Debug + Copy,

    \ No newline at end of file diff --git a/ch5/os/mm/fn.frame_alloc.html b/ch5/os/mm/fn.frame_alloc.html index 3126dfa9..c85dde37 100644 --- a/ch5/os/mm/fn.frame_alloc.html +++ b/ch5/os/mm/fn.frame_alloc.html @@ -1,2 +1,2 @@ -frame_alloc in os::mm - Rust

    Function os::mm::frame_alloc

    source · [−]
    pub fn frame_alloc() -> Option<FrameTracker>
    Expand description

    allocate a frame

    -
    \ No newline at end of file +frame_alloc in os::mm - Rust

    Function os::mm::frame_alloc

    source · 
    pub fn frame_alloc() -> Option<FrameTracker>
    Expand description

    allocate a frame

    +
    \ No newline at end of file diff --git a/ch5/os/mm/fn.init.html b/ch5/os/mm/fn.init.html index a1c0bb1f..bbb442bd 100644 --- a/ch5/os/mm/fn.init.html +++ b/ch5/os/mm/fn.init.html @@ -1,2 +1,2 @@ -init in os::mm - Rust

    Function os::mm::init

    source · [−]
    pub fn init()
    Expand description

    initiate heap allocator, frame allocator and kernel space

    -
    \ No newline at end of file +init in os::mm - Rust

    Function os::mm::init

    source · 
    pub fn init()
    Expand description

    initiate heap allocator, frame allocator and kernel space

    +
    \ No newline at end of file diff --git a/ch5/os/mm/fn.remap_test.html b/ch5/os/mm/fn.remap_test.html index 10f46eff..dd6a9410 100644 --- a/ch5/os/mm/fn.remap_test.html +++ b/ch5/os/mm/fn.remap_test.html @@ -1,2 +1,2 @@ -remap_test in os::mm - Rust

    Function os::mm::remap_test

    source · [−]
    pub fn remap_test()
    Expand description

    Check PageTable running correctly

    -
    \ No newline at end of file +remap_test in os::mm - Rust

    Function os::mm::remap_test

    source · 
    pub fn remap_test()
    Expand description

    Check PageTable running correctly

    +
    \ No newline at end of file diff --git a/ch5/os/mm/fn.translated_byte_buffer.html b/ch5/os/mm/fn.translated_byte_buffer.html index 06950317..132ad6c5 100644 --- a/ch5/os/mm/fn.translated_byte_buffer.html +++ b/ch5/os/mm/fn.translated_byte_buffer.html @@ -1,2 +1,6 @@ -translated_byte_buffer in os::mm - Rust

    Function os::mm::translated_byte_buffer

    source · [−]
    pub fn translated_byte_buffer(
        token: usize,
        ptr: *const u8,
        len: usize
    ) -> Vec<&'static mut [u8]>
    Expand description

    translate a pointer to a mutable u8 Vec through page table

    -
    \ No newline at end of file +translated_byte_buffer in os::mm - Rust

    Function os::mm::translated_byte_buffer

    source · 
    pub fn translated_byte_buffer(
+    token: usize,
+    ptr: *const u8,
+    len: usize
+) -> Vec<&'static mut [u8]>
    Expand description

    translate a pointer to a mutable u8 Vec through page table

    +
    \ No newline at end of file diff --git a/ch5/os/mm/fn.translated_refmut.html b/ch5/os/mm/fn.translated_refmut.html index 75749984..df1ed019 100644 --- a/ch5/os/mm/fn.translated_refmut.html +++ b/ch5/os/mm/fn.translated_refmut.html @@ -1,2 +1,2 @@ -translated_refmut in os::mm - Rust

    Function os::mm::translated_refmut

    source · [−]
    pub fn translated_refmut<T>(token: usize, ptr: *mut T) -> &'static mut T
    Expand description

    translate a generic through page table and return a mutable reference

    -
    \ No newline at end of file +translated_refmut in os::mm - Rust

    Function os::mm::translated_refmut

    source · 
    pub fn translated_refmut<T>(token: usize, ptr: *mut T) -> &'static mut T
    Expand description

    translate a generic through page table and return a mutable reference

    +
    \ No newline at end of file diff --git a/ch5/os/mm/fn.translated_str.html b/ch5/os/mm/fn.translated_str.html index 1dbb9a24..bf957511 100644 --- a/ch5/os/mm/fn.translated_str.html +++ b/ch5/os/mm/fn.translated_str.html @@ -1,2 +1,2 @@ -translated_str in os::mm - Rust

    Function os::mm::translated_str

    source · [−]
    pub fn translated_str(token: usize, ptr: *const u8) -> String
    Expand description

    translate a pointer to a mutable u8 Vec end with \0 through page table to a String

    -
    \ No newline at end of file +translated_str in os::mm - Rust

    Function os::mm::translated_str

    source · 
    pub fn translated_str(token: usize, ptr: *const u8) -> String
    Expand description

    translate a pointer to a mutable u8 Vec end with \0 through page table to a String

    +
    \ No newline at end of file diff --git a/ch5/os/mm/frame_allocator/fn.frame_alloc.html b/ch5/os/mm/frame_allocator/fn.frame_alloc.html index e6207176..b611ff59 100644 --- a/ch5/os/mm/frame_allocator/fn.frame_alloc.html +++ b/ch5/os/mm/frame_allocator/fn.frame_alloc.html @@ -1,2 +1,2 @@ -frame_alloc in os::mm::frame_allocator - Rust

    Function os::mm::frame_allocator::frame_alloc

    source · [−]
    pub fn frame_alloc() -> Option<FrameTracker>
    Expand description

    allocate a frame

    -
    \ No newline at end of file +frame_alloc in os::mm::frame_allocator - Rust

    Function os::mm::frame_allocator::frame_alloc

    source · 
    pub fn frame_alloc() -> Option<FrameTracker>
    Expand description

    allocate a frame

    +
    \ No newline at end of file diff --git a/ch5/os/mm/frame_allocator/fn.frame_allocator_test.html b/ch5/os/mm/frame_allocator/fn.frame_allocator_test.html index ad420f38..e4ebf6de 100644 --- a/ch5/os/mm/frame_allocator/fn.frame_allocator_test.html +++ b/ch5/os/mm/frame_allocator/fn.frame_allocator_test.html @@ -1,2 +1,2 @@ -frame_allocator_test in os::mm::frame_allocator - Rust

    Function os::mm::frame_allocator::frame_allocator_test

    source · [−]
    pub fn frame_allocator_test()
    Expand description

    a simple test for frame allocator

    -
    \ No newline at end of file +frame_allocator_test in os::mm::frame_allocator - Rust

    Function os::mm::frame_allocator::frame_allocator_test

    source · 
    pub fn frame_allocator_test()
    Expand description

    a simple test for frame allocator

    +
    \ No newline at end of file diff --git a/ch5/os/mm/frame_allocator/fn.frame_dealloc.html b/ch5/os/mm/frame_allocator/fn.frame_dealloc.html index 5f96995e..51835260 100644 --- a/ch5/os/mm/frame_allocator/fn.frame_dealloc.html +++ b/ch5/os/mm/frame_allocator/fn.frame_dealloc.html @@ -1,2 +1,2 @@ -frame_dealloc in os::mm::frame_allocator - Rust

    Function os::mm::frame_allocator::frame_dealloc

    source · [−]
    fn frame_dealloc(ppn: PhysPageNum)
    Expand description

    deallocate a frame

    -
    \ No newline at end of file +frame_dealloc in os::mm::frame_allocator - Rust

    Function os::mm::frame_allocator::frame_dealloc

    source · 
    fn frame_dealloc(ppn: PhysPageNum)
    Expand description

    deallocate a frame

    +
    \ No newline at end of file diff --git a/ch5/os/mm/frame_allocator/fn.init_frame_allocator.html b/ch5/os/mm/frame_allocator/fn.init_frame_allocator.html index 948aa858..bb1fde60 100644 --- a/ch5/os/mm/frame_allocator/fn.init_frame_allocator.html +++ b/ch5/os/mm/frame_allocator/fn.init_frame_allocator.html @@ -1,2 +1,2 @@ -init_frame_allocator in os::mm::frame_allocator - Rust

    Function os::mm::frame_allocator::init_frame_allocator

    source · [−]
    pub fn init_frame_allocator()
    Expand description

    initiate the frame allocator using ekernel and MEMORY_END

    -
    \ No newline at end of file +init_frame_allocator in os::mm::frame_allocator - Rust

    Function os::mm::frame_allocator::init_frame_allocator

    source · 
    pub fn init_frame_allocator()
    Expand description

    initiate the frame allocator using ekernel and MEMORY_END

    +
    \ No newline at end of file diff --git a/ch5/os/mm/frame_allocator/index.html b/ch5/os/mm/frame_allocator/index.html index 82bc5387..36d9cd19 100644 --- a/ch5/os/mm/frame_allocator/index.html +++ b/ch5/os/mm/frame_allocator/index.html @@ -1,10 +1,3 @@ -os::mm::frame_allocator - Rust

    Module os::mm::frame_allocator

    source · [−]
    Expand description

    Implementation of FrameAllocator which +os::mm::frame_allocator - Rust

    Module os::mm::frame_allocator

    source ·
    Expand description

    Implementation of FrameAllocator which controls all the frames in the operating system.

    -

    Structs

    FRAME_ALLOCATOR

    frame allocator instance through lazy_static!

    -
    FrameTracker

    manage a frame which has the same lifecycle as the tracker

    -
    StackFrameAllocator

    an implementation for frame allocator

    -

    Traits

    FrameAllocator 🔒

    Functions

    frame_alloc

    allocate a frame

    -
    frame_allocator_test

    a simple test for frame allocator

    -
    frame_dealloc 🔒

    deallocate a frame

    -
    init_frame_allocator

    initiate the frame allocator using ekernel and MEMORY_END

    -

    Type Definitions

    FrameAllocatorImpl 🔒
    \ No newline at end of file +

    Structs

    Traits

    Functions

    Type Aliases

    \ No newline at end of file diff --git a/ch5/os/mm/frame_allocator/sidebar-items.js b/ch5/os/mm/frame_allocator/sidebar-items.js index 26d4088d..be15c50b 100644 --- a/ch5/os/mm/frame_allocator/sidebar-items.js +++ b/ch5/os/mm/frame_allocator/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"fn":[["frame_alloc","allocate a frame"],["frame_allocator_test","a simple test for frame allocator"],["frame_dealloc","deallocate a frame"],["init_frame_allocator","initiate the frame allocator using `ekernel` and `MEMORY_END`"]],"struct":[["FRAME_ALLOCATOR","frame allocator instance through lazy_static!"],["FrameTracker","manage a frame which has the same lifecycle as the tracker"],["StackFrameAllocator","an implementation for frame allocator"]],"trait":[["FrameAllocator",""]],"type":[["FrameAllocatorImpl",""]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"fn":["frame_alloc","frame_allocator_test","frame_dealloc","init_frame_allocator"],"struct":["FRAME_ALLOCATOR","FrameTracker","StackFrameAllocator"],"trait":["FrameAllocator"],"type":["FrameAllocatorImpl"]}; \ No newline at end of file diff --git a/ch5/os/mm/frame_allocator/struct.FRAME_ALLOCATOR.html b/ch5/os/mm/frame_allocator/struct.FRAME_ALLOCATOR.html index fb04cb9f..9595de47 100644 --- a/ch5/os/mm/frame_allocator/struct.FRAME_ALLOCATOR.html +++ b/ch5/os/mm/frame_allocator/struct.FRAME_ALLOCATOR.html @@ -1,18 +1,15 @@ -FRAME_ALLOCATOR in os::mm::frame_allocator - Rust

    Struct os::mm::frame_allocator::FRAME_ALLOCATOR

    source · [−]
    pub struct FRAME_ALLOCATOR {
+FRAME_ALLOCATOR in os::mm::frame_allocator - Rust
    Struct os::mm::frame_allocator::FRAME_ALLOCATOR
    source · 
    pub struct FRAME_ALLOCATOR {
     __private_field: (),
-}
    Expand description
    frame allocator instance through lazy_static!
    
-
    Fields
    __private_field: ()
    Methods from Deref<Target = UPSafeCell<StackFrameAllocator>>
    Exclusive access inner data in UPSafeCell. Panic if the data has been borrowed.
    
-
    Trait Implementations
    The resulting type after dereferencing.
    
-
    Dereferences the value.
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}
    Expand description

    frame allocator instance through lazy_static!

    +

    Fields§

    §__private_field: ()

    Methods from Deref<Target = UPSafeCell<StackFrameAllocator>>§

    source

    pub fn exclusive_access(&self) -> RefMut<'_, T>

    Exclusive access inner data in UPSafeCell. Panic if the data has been borrowed.

    +

    Trait Implementations§

    source§

    impl Deref for FRAME_ALLOCATOR

    §

    type Target = UPSafeCell<StackFrameAllocator>

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &UPSafeCell<StackFrameAllocator>

    Dereferences the value.
    source§

    impl LazyStatic for FRAME_ALLOCATOR

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/frame_allocator/struct.FrameTracker.html b/ch5/os/mm/frame_allocator/struct.FrameTracker.html index 9167fa1c..bfbc576a 100644 --- a/ch5/os/mm/frame_allocator/struct.FrameTracker.html +++ b/ch5/os/mm/frame_allocator/struct.FrameTracker.html @@ -1,18 +1,15 @@ -FrameTracker in os::mm::frame_allocator - Rust

    Struct os::mm::frame_allocator::FrameTracker

    source · [−]
    pub struct FrameTracker {
+FrameTracker in os::mm::frame_allocator - Rust
    Struct os::mm::frame_allocator::FrameTracker
    source · 
    pub struct FrameTracker {
     pub ppn: PhysPageNum,
-}
    Expand description
    manage a frame which has the same lifecycle as the tracker
    
-
    Fields
    ppn: PhysPageNum
    Implementations
    Create an empty FrameTracker
    
-
    Trait Implementations
    Formats the value using the given formatter. Read more
    
-
    Executes the destructor for this type. Read more
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}
    Expand description

    manage a frame which has the same lifecycle as the tracker

    +

    Fields§

    §ppn: PhysPageNum

    Implementations§

    source§

    impl FrameTracker

    source

    pub fn new(ppn: PhysPageNum) -> Self

    Create an empty FrameTracker

    +

    Trait Implementations§

    source§

    impl Debug for FrameTracker

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl Drop for FrameTracker

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/frame_allocator/struct.StackFrameAllocator.html b/ch5/os/mm/frame_allocator/struct.StackFrameAllocator.html index ca477e22..935b87bd 100644 --- a/ch5/os/mm/frame_allocator/struct.StackFrameAllocator.html +++ b/ch5/os/mm/frame_allocator/struct.StackFrameAllocator.html @@ -1,17 +1,16 @@ -StackFrameAllocator in os::mm::frame_allocator - Rust

    Struct os::mm::frame_allocator::StackFrameAllocator

    source · [−]
    pub struct StackFrameAllocator {
+StackFrameAllocator in os::mm::frame_allocator - Rust
    Struct os::mm::frame_allocator::StackFrameAllocator
    source · 
    pub struct StackFrameAllocator {
     current: usize,
     end: usize,
     recycled: Vec<usize>,
-}
    Expand description
    an implementation for frame allocator
    
-
    Fields
    current: usizeend: usizerecycled: Vec<usize>
    Implementations
    Trait Implementations
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}
    Expand description

    an implementation for frame allocator

    +

    Fields§

    §current: usize§end: usize§recycled: Vec<usize>

    Implementations§

    Trait Implementations§

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/frame_allocator/trait.FrameAllocator.html b/ch5/os/mm/frame_allocator/trait.FrameAllocator.html index 3df2abda..28041a23 100644 --- a/ch5/os/mm/frame_allocator/trait.FrameAllocator.html +++ b/ch5/os/mm/frame_allocator/trait.FrameAllocator.html @@ -1,5 +1,6 @@ -FrameAllocator in os::mm::frame_allocator - Rust

    Trait os::mm::frame_allocator::FrameAllocator

    source · [−]
    trait FrameAllocator {
-    fn new() -> Self;
-    fn alloc(&mut self) -> Option<PhysPageNum>;
-    fn dealloc(&mut self, ppn: PhysPageNum);
-}

    Required Methods

    Implementors

    \ No newline at end of file +FrameAllocator in os::mm::frame_allocator - Rust

    Trait os::mm::frame_allocator::FrameAllocator

    source · 
    trait FrameAllocator {
+    // Required methods
+    fn new() -> Self;
+    fn alloc(&mut self) -> Option<PhysPageNum>;
+    fn dealloc(&mut self, ppn: PhysPageNum);
+}

    Required Methods§

    source

    fn new() -> Self

    source

    fn alloc(&mut self) -> Option<PhysPageNum>

    source

    fn dealloc(&mut self, ppn: PhysPageNum)

    Implementors§

    \ No newline at end of file diff --git a/ch5/os/mm/frame_allocator/type.FrameAllocatorImpl.html b/ch5/os/mm/frame_allocator/type.FrameAllocatorImpl.html index 2a27d08a..235bf775 100644 --- a/ch5/os/mm/frame_allocator/type.FrameAllocatorImpl.html +++ b/ch5/os/mm/frame_allocator/type.FrameAllocatorImpl.html @@ -1 +1,5 @@ -FrameAllocatorImpl in os::mm::frame_allocator - Rust

    Type Definition os::mm::frame_allocator::FrameAllocatorImpl

    source · [−]
    type FrameAllocatorImpl = StackFrameAllocator;
    \ No newline at end of file +FrameAllocatorImpl in os::mm::frame_allocator - Rust

    Type Alias os::mm::frame_allocator::FrameAllocatorImpl

    source · 
    type FrameAllocatorImpl = StackFrameAllocator;

    Aliased Type§

    struct FrameAllocatorImpl {
+    current: usize,
+    end: usize,
+    recycled: Vec<usize, Global>,
+}

    Fields§

    §current: usize§end: usize§recycled: Vec<usize, Global>

    Implementations§

    Trait Implementations§

    \ No newline at end of file diff --git a/ch5/os/mm/heap_allocator/fn.handle_alloc_error.html b/ch5/os/mm/heap_allocator/fn.handle_alloc_error.html index 8e13a4d5..6bb35dfb 100644 --- a/ch5/os/mm/heap_allocator/fn.handle_alloc_error.html +++ b/ch5/os/mm/heap_allocator/fn.handle_alloc_error.html @@ -1,2 +1,2 @@ -handle_alloc_error in os::mm::heap_allocator - Rust

    Function os::mm::heap_allocator::handle_alloc_error

    source · [−]
    pub fn handle_alloc_error(layout: Layout) -> !
    Expand description

    panic when heap allocation error occurs

    -
    \ No newline at end of file +handle_alloc_error in os::mm::heap_allocator - Rust

    Function os::mm::heap_allocator::handle_alloc_error

    source · 
    pub fn handle_alloc_error(layout: Layout) -> !
    Expand description

    panic when heap allocation error occurs

    +
    \ No newline at end of file diff --git a/ch5/os/mm/heap_allocator/fn.heap_test.html b/ch5/os/mm/heap_allocator/fn.heap_test.html index 87a16d46..5de05955 100644 --- a/ch5/os/mm/heap_allocator/fn.heap_test.html +++ b/ch5/os/mm/heap_allocator/fn.heap_test.html @@ -1 +1 @@ -heap_test in os::mm::heap_allocator - Rust

    Function os::mm::heap_allocator::heap_test

    source · [−]
    pub fn heap_test()
    \ No newline at end of file +heap_test in os::mm::heap_allocator - Rust

    Function os::mm::heap_allocator::heap_test

    source · 
    pub fn heap_test()
    \ No newline at end of file diff --git a/ch5/os/mm/heap_allocator/fn.init_heap.html b/ch5/os/mm/heap_allocator/fn.init_heap.html index 9983266d..03da3c6e 100644 --- a/ch5/os/mm/heap_allocator/fn.init_heap.html +++ b/ch5/os/mm/heap_allocator/fn.init_heap.html @@ -1,2 +1,2 @@ -init_heap in os::mm::heap_allocator - Rust

    Function os::mm::heap_allocator::init_heap

    source · [−]
    pub fn init_heap()
    Expand description

    initiate heap allocator

    -
    \ No newline at end of file +init_heap in os::mm::heap_allocator - Rust

    Function os::mm::heap_allocator::init_heap

    source · 
    pub fn init_heap()
    Expand description

    initiate heap allocator

    +
    \ No newline at end of file diff --git a/ch5/os/mm/heap_allocator/index.html b/ch5/os/mm/heap_allocator/index.html index 05472122..e99493c8 100644 --- a/ch5/os/mm/heap_allocator/index.html +++ b/ch5/os/mm/heap_allocator/index.html @@ -1,6 +1,2 @@ -os::mm::heap_allocator - Rust

    Module os::mm::heap_allocator

    source · [−]
    Expand description

    The global allocator

    -

    Statics

    HEAP_ALLOCATOR 🔒

    heap allocator instance

    -
    HEAP_SPACE 🔒

    heap space ([u8; KERNEL_HEAP_SIZE])

    -

    Functions

    handle_alloc_error

    panic when heap allocation error occurs

    -
    heap_test
    init_heap

    initiate heap allocator

    -
    \ No newline at end of file +os::mm::heap_allocator - Rust

    Module os::mm::heap_allocator

    source ·
    Expand description

    The global allocator

    +

    Statics

    Functions

    \ No newline at end of file diff --git a/ch5/os/mm/heap_allocator/sidebar-items.js b/ch5/os/mm/heap_allocator/sidebar-items.js index 7d2480db..d5956da4 100644 --- a/ch5/os/mm/heap_allocator/sidebar-items.js +++ b/ch5/os/mm/heap_allocator/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"fn":[["handle_alloc_error","panic when heap allocation error occurs"],["heap_test",""],["init_heap","initiate heap allocator"]],"static":[["HEAP_ALLOCATOR","heap allocator instance"],["HEAP_SPACE","heap space ([u8; KERNEL_HEAP_SIZE])"]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"fn":["handle_alloc_error","heap_test","init_heap"],"static":["HEAP_ALLOCATOR","HEAP_SPACE"]}; \ No newline at end of file diff --git a/ch5/os/mm/heap_allocator/static.HEAP_ALLOCATOR.html b/ch5/os/mm/heap_allocator/static.HEAP_ALLOCATOR.html index f91d542d..3761e118 100644 --- a/ch5/os/mm/heap_allocator/static.HEAP_ALLOCATOR.html +++ b/ch5/os/mm/heap_allocator/static.HEAP_ALLOCATOR.html @@ -1,2 +1,2 @@ -HEAP_ALLOCATOR in os::mm::heap_allocator - Rust

    Static os::mm::heap_allocator::HEAP_ALLOCATOR

    source · [−]
    static HEAP_ALLOCATOR: LockedHeap
    Expand description

    heap allocator instance

    -
    \ No newline at end of file +HEAP_ALLOCATOR in os::mm::heap_allocator - Rust

    Static os::mm::heap_allocator::HEAP_ALLOCATOR

    source · 
    static HEAP_ALLOCATOR: LockedHeap
    Expand description

    heap allocator instance

    +
    \ No newline at end of file diff --git a/ch5/os/mm/heap_allocator/static.HEAP_SPACE.html b/ch5/os/mm/heap_allocator/static.HEAP_SPACE.html index c4b9180f..1d6274fc 100644 --- a/ch5/os/mm/heap_allocator/static.HEAP_SPACE.html +++ b/ch5/os/mm/heap_allocator/static.HEAP_SPACE.html @@ -1,2 +1,2 @@ -HEAP_SPACE in os::mm::heap_allocator - Rust

    Static os::mm::heap_allocator::HEAP_SPACE

    source · [−]
    static mut HEAP_SPACE: [u8; 2097152]
    Expand description

    heap space ([u8; KERNEL_HEAP_SIZE])

    -
    \ No newline at end of file +HEAP_SPACE in os::mm::heap_allocator - Rust

    Static os::mm::heap_allocator::HEAP_SPACE

    source · 
    static mut HEAP_SPACE: [u8; 2097152]
    Expand description

    heap space ([u8; KERNEL_HEAP_SIZE])

    +
    \ No newline at end of file diff --git a/ch5/os/mm/index.html b/ch5/os/mm/index.html index 6b507979..8ea05843 100644 --- a/ch5/os/mm/index.html +++ b/ch5/os/mm/index.html @@ -1,27 +1,7 @@ -os::mm - Rust

    Module os::mm

    source · [−]
    Expand description

    Memory management implementation

    +os::mm - Rust

    Module os::mm

    source ·
    Expand description

    Memory management implementation

    SV39 page-based virtual-memory architecture for RV64 systems, and everything about memory management, like frame allocator, page table, map area and memory set, is implemented here.

    Every task or process has a memory_set to control its virtual memory.

    -

    Modules

    address 🔒

    Implementation of physical and virtual address and page number.

    -
    frame_allocator 🔒

    Implementation of FrameAllocator which -controls all the frames in the operating system.

    -
    heap_allocator 🔒

    The global allocator

    -
    memory_set 🔒

    Implementation of MapArea and MemorySet.

    -
    page_table 🔒

    Implementation of PageTableEntry and PageTable.

    -

    Structs

    FrameTracker

    manage a frame which has the same lifecycle as the tracker

    -
    KERNEL_SPACE

    a memory set instance through lazy_static! managing kernel space

    -
    MapPermission

    map permission corresponding to that in pte: R W X U

    -
    MemorySet

    memory set structure, controls virtual-memory space

    -
    PageTableEntry

    page table entry structure

    -
    PhysAddr

    physical address

    -
    PhysPageNum

    physical page number

    -
    VirtAddr

    virtual address

    -
    VirtPageNum

    virtual page number

    -

    Functions

    frame_alloc

    allocate a frame

    -
    init

    initiate heap allocator, frame allocator and kernel space

    -
    remap_test

    Check PageTable running correctly

    -
    translated_byte_buffer

    translate a pointer to a mutable u8 Vec through page table

    -
    translated_refmut

    translate a generic through page table and return a mutable reference

    -
    translated_str

    translate a pointer to a mutable u8 Vec end with \0 through page table to a String

    -
    \ No newline at end of file +

    Re-exports

    • pub use memory_set::KERNEL_SPACE;
    • pub use memory_set::KERNEL_SPACE;

    Modules

    Structs

    Functions

    • frame_alloc
      allocate a frame
    • init
      initiate heap allocator, frame allocator and kernel space
    • remap_test
      Check PageTable running correctly
    • translated_byte_buffer
      translate a pointer to a mutable u8 Vec through page table
    • translated_refmut
      translate a generic through page table and return a mutable reference
    • translated_str
      translate a pointer to a mutable u8 Vec end with \0 through page table to a String
    \ No newline at end of file diff --git a/ch5/os/mm/memory_set/enum.MapType.html b/ch5/os/mm/memory_set/enum.MapType.html index cba20314..31259549 100644 --- a/ch5/os/mm/memory_set/enum.MapType.html +++ b/ch5/os/mm/memory_set/enum.MapType.html @@ -1,25 +1,18 @@ -MapType in os::mm::memory_set - Rust

    Enum os::mm::memory_set::MapType

    source · [−]
    pub enum MapType {
+MapType in os::mm::memory_set - Rust
    Enum os::mm::memory_set::MapType
    source · 
    pub enum MapType {
     Identical,
     Framed,
-}
    Expand description
    map type for memory set: identical or framed
    
-
    Variants
    Identical
    Framed
    Trait Implementations
    Returns a copy of the value. Read more
    
-
    Performs copy-assignment from source. Read more
    
-
    Formats the value using the given formatter. Read more
    
-
    This method tests for self and other values to be equal, and is used
-by ==. Read more
    
-
    This method tests for !=.
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}
    Expand description

    map type for memory set: identical or framed

    +

    Variants§

    §

    Identical

    §

    Framed

    Trait Implementations§

    source§

    impl Clone for MapType

    source§

    fn clone(&self) -> MapType

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for MapType

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl PartialEq<MapType> for MapType

    source§

    fn eq(&self, other: &MapType) -> bool

    This method tests for self and other values to be equal, and is used +by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always +sufficient, and should not be overridden without very good reason.
    source§

    impl Copy for MapType

    source§

    impl StructuralPartialEq for MapType

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The resulting type after obtaining ownership.

    -

    Creates owned data from borrowed data, usually by cloning. Read more

    -

    Uses borrowed data to replace owned data, usually by cloning. Read more

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T> ToOwned for Twhere + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/memory_set/fn.ebss.html b/ch5/os/mm/memory_set/fn.ebss.html index c9568848..2b13c3d5 100644 --- a/ch5/os/mm/memory_set/fn.ebss.html +++ b/ch5/os/mm/memory_set/fn.ebss.html @@ -1 +1 @@ -ebss in os::mm::memory_set - Rust

    Function os::mm::memory_set::ebss

    source · [−]
    unsafe extern "C" fn ebss()
    \ No newline at end of file +ebss in os::mm::memory_set - Rust

    Function os::mm::memory_set::ebss

    source · 
    unsafe extern "C" fn ebss()
    \ No newline at end of file diff --git a/ch5/os/mm/memory_set/fn.edata.html b/ch5/os/mm/memory_set/fn.edata.html index 9ccf48d0..6692613e 100644 --- a/ch5/os/mm/memory_set/fn.edata.html +++ b/ch5/os/mm/memory_set/fn.edata.html @@ -1 +1 @@ -edata in os::mm::memory_set - Rust

    Function os::mm::memory_set::edata

    source · [−]
    unsafe extern "C" fn edata()
    \ No newline at end of file +edata in os::mm::memory_set - Rust

    Function os::mm::memory_set::edata

    source · 
    unsafe extern "C" fn edata()
    \ No newline at end of file diff --git a/ch5/os/mm/memory_set/fn.ekernel.html b/ch5/os/mm/memory_set/fn.ekernel.html index c8d8df92..776a8212 100644 --- a/ch5/os/mm/memory_set/fn.ekernel.html +++ b/ch5/os/mm/memory_set/fn.ekernel.html @@ -1 +1 @@ -ekernel in os::mm::memory_set - Rust

    Function os::mm::memory_set::ekernel

    source · [−]
    unsafe extern "C" fn ekernel()
    \ No newline at end of file +ekernel in os::mm::memory_set - Rust

    Function os::mm::memory_set::ekernel

    source · 
    unsafe extern "C" fn ekernel()
    \ No newline at end of file diff --git a/ch5/os/mm/memory_set/fn.erodata.html b/ch5/os/mm/memory_set/fn.erodata.html index 8034b1eb..59b2a302 100644 --- a/ch5/os/mm/memory_set/fn.erodata.html +++ b/ch5/os/mm/memory_set/fn.erodata.html @@ -1 +1 @@ -erodata in os::mm::memory_set - Rust

    Function os::mm::memory_set::erodata

    source · [−]
    unsafe extern "C" fn erodata()
    \ No newline at end of file +erodata in os::mm::memory_set - Rust

    Function os::mm::memory_set::erodata

    source · 
    unsafe extern "C" fn erodata()
    \ No newline at end of file diff --git a/ch5/os/mm/memory_set/fn.etext.html b/ch5/os/mm/memory_set/fn.etext.html index 36471060..ea098077 100644 --- a/ch5/os/mm/memory_set/fn.etext.html +++ b/ch5/os/mm/memory_set/fn.etext.html @@ -1 +1 @@ -etext in os::mm::memory_set - Rust

    Function os::mm::memory_set::etext

    source · [−]
    unsafe extern "C" fn etext()
    \ No newline at end of file +etext in os::mm::memory_set - Rust

    Function os::mm::memory_set::etext

    source · 
    unsafe extern "C" fn etext()
    \ No newline at end of file diff --git a/ch5/os/mm/memory_set/fn.remap_test.html b/ch5/os/mm/memory_set/fn.remap_test.html index c2104c88..eb82d41d 100644 --- a/ch5/os/mm/memory_set/fn.remap_test.html +++ b/ch5/os/mm/memory_set/fn.remap_test.html @@ -1,2 +1,2 @@ -remap_test in os::mm::memory_set - Rust

    Function os::mm::memory_set::remap_test

    source · [−]
    pub fn remap_test()
    Expand description

    Check PageTable running correctly

    -
    \ No newline at end of file +remap_test in os::mm::memory_set - Rust

    Function os::mm::memory_set::remap_test

    source · 
    pub fn remap_test()
    Expand description

    Check PageTable running correctly

    +
    \ No newline at end of file diff --git a/ch5/os/mm/memory_set/fn.sbss_with_stack.html b/ch5/os/mm/memory_set/fn.sbss_with_stack.html index ff32cd95..aa9603cd 100644 --- a/ch5/os/mm/memory_set/fn.sbss_with_stack.html +++ b/ch5/os/mm/memory_set/fn.sbss_with_stack.html @@ -1 +1 @@ -sbss_with_stack in os::mm::memory_set - Rust

    Function os::mm::memory_set::sbss_with_stack

    source · [−]
    unsafe extern "C" fn sbss_with_stack()
    \ No newline at end of file +sbss_with_stack in os::mm::memory_set - Rust

    Function os::mm::memory_set::sbss_with_stack

    source · 
    unsafe extern "C" fn sbss_with_stack()
    \ No newline at end of file diff --git a/ch5/os/mm/memory_set/fn.sdata.html b/ch5/os/mm/memory_set/fn.sdata.html index e7af7f15..f57910fc 100644 --- a/ch5/os/mm/memory_set/fn.sdata.html +++ b/ch5/os/mm/memory_set/fn.sdata.html @@ -1 +1 @@ -sdata in os::mm::memory_set - Rust

    Function os::mm::memory_set::sdata

    source · [−]
    unsafe extern "C" fn sdata()
    \ No newline at end of file +sdata in os::mm::memory_set - Rust

    Function os::mm::memory_set::sdata

    source · 
    unsafe extern "C" fn sdata()
    \ No newline at end of file diff --git a/ch5/os/mm/memory_set/fn.srodata.html b/ch5/os/mm/memory_set/fn.srodata.html index eed5ba21..04b75488 100644 --- a/ch5/os/mm/memory_set/fn.srodata.html +++ b/ch5/os/mm/memory_set/fn.srodata.html @@ -1 +1 @@ -srodata in os::mm::memory_set - Rust

    Function os::mm::memory_set::srodata

    source · [−]
    unsafe extern "C" fn srodata()
    \ No newline at end of file +srodata in os::mm::memory_set - Rust

    Function os::mm::memory_set::srodata

    source · 
    unsafe extern "C" fn srodata()
    \ No newline at end of file diff --git a/ch5/os/mm/memory_set/fn.stext.html b/ch5/os/mm/memory_set/fn.stext.html index 088ece06..7d72ec3a 100644 --- a/ch5/os/mm/memory_set/fn.stext.html +++ b/ch5/os/mm/memory_set/fn.stext.html @@ -1 +1 @@ -stext in os::mm::memory_set - Rust

    Function os::mm::memory_set::stext

    source · [−]
    unsafe extern "C" fn stext()
    \ No newline at end of file +stext in os::mm::memory_set - Rust

    Function os::mm::memory_set::stext

    source · 
    unsafe extern "C" fn stext()
    \ No newline at end of file diff --git a/ch5/os/mm/memory_set/fn.strampoline.html b/ch5/os/mm/memory_set/fn.strampoline.html index b76b16d9..fb5dd69d 100644 --- a/ch5/os/mm/memory_set/fn.strampoline.html +++ b/ch5/os/mm/memory_set/fn.strampoline.html @@ -1 +1 @@ -strampoline in os::mm::memory_set - Rust

    Function os::mm::memory_set::strampoline

    source · [−]
    unsafe extern "C" fn strampoline()
    \ No newline at end of file +strampoline in os::mm::memory_set - Rust

    Function os::mm::memory_set::strampoline

    source · 
    unsafe extern "C" fn strampoline()
    \ No newline at end of file diff --git a/ch5/os/mm/memory_set/index.html b/ch5/os/mm/memory_set/index.html index ec3579a6..2f7d218a 100644 --- a/ch5/os/mm/memory_set/index.html +++ b/ch5/os/mm/memory_set/index.html @@ -1,8 +1,2 @@ -os::mm::memory_set - Rust

    Module os::mm::memory_set

    source · [−]
    Expand description

    Implementation of MapArea and MemorySet.

    -

    Structs

    KERNEL_SPACE

    a memory set instance through lazy_static! managing kernel space

    -
    MapArea

    map area structure, controls a contiguous piece of virtual memory

    -
    MapPermission

    map permission corresponding to that in pte: R W X U

    -
    MemorySet

    memory set structure, controls virtual-memory space

    -

    Enums

    MapType

    map type for memory set: identical or framed

    -

    Functions

    ebss 🔒 ⚠
    edata 🔒 ⚠
    ekernel 🔒 ⚠
    erodata 🔒 ⚠
    etext 🔒 ⚠
    remap_test

    Check PageTable running correctly

    -
    sbss_with_stack 🔒 ⚠
    sdata 🔒 ⚠
    srodata 🔒 ⚠
    stext 🔒 ⚠
    strampoline 🔒 ⚠
    \ No newline at end of file +os::mm::memory_set - Rust

    Module os::mm::memory_set

    source ·
    Expand description

    Implementation of MapArea and MemorySet.

    +

    Structs

    • KERNEL_SPACE
      a memory set instance through lazy_static! managing kernel space
    • MapArea
      map area structure, controls a contiguous piece of virtual memory
    • MapPermission
      map permission corresponding to that in pte: R W X U
    • MemorySet
      memory set structure, controls virtual-memory space

    Enums

    • MapType
      map type for memory set: identical or framed

    Functions

    \ No newline at end of file diff --git a/ch5/os/mm/memory_set/sidebar-items.js b/ch5/os/mm/memory_set/sidebar-items.js index 8953e712..2622ef9c 100644 --- a/ch5/os/mm/memory_set/sidebar-items.js +++ b/ch5/os/mm/memory_set/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"enum":[["MapType","map type for memory set: identical or framed"]],"fn":[["ebss",""],["edata",""],["ekernel",""],["erodata",""],["etext",""],["remap_test","Check PageTable running correctly"],["sbss_with_stack",""],["sdata",""],["srodata",""],["stext",""],["strampoline",""]],"struct":[["KERNEL_SPACE","a memory set instance through lazy_static! managing kernel space"],["MapArea","map area structure, controls a contiguous piece of virtual memory"],["MapPermission","map permission corresponding to that in pte: `R W X U`"],["MemorySet","memory set structure, controls virtual-memory space"]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"enum":["MapType"],"fn":["ebss","edata","ekernel","erodata","etext","remap_test","sbss_with_stack","sdata","srodata","stext","strampoline"],"struct":["KERNEL_SPACE","MapArea","MapPermission","MemorySet"]}; \ No newline at end of file diff --git a/ch5/os/mm/memory_set/struct.KERNEL_SPACE.html b/ch5/os/mm/memory_set/struct.KERNEL_SPACE.html index 62dde97b..df99208f 100644 --- a/ch5/os/mm/memory_set/struct.KERNEL_SPACE.html +++ b/ch5/os/mm/memory_set/struct.KERNEL_SPACE.html @@ -1,17 +1,14 @@ -KERNEL_SPACE in os::mm::memory_set - Rust

    Struct os::mm::memory_set::KERNEL_SPACE

    source · [−]
    pub struct KERNEL_SPACE {
+KERNEL_SPACE in os::mm::memory_set - Rust
    Struct os::mm::memory_set::KERNEL_SPACE
    source · 
    pub struct KERNEL_SPACE {
     __private_field: (),
-}
    Expand description
    a memory set instance through lazy_static! managing kernel space
    
-
    Fields
    __private_field: ()
    Trait Implementations
    The resulting type after dereferencing.
    
-
    Dereferences the value.
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}
    Expand description

    a memory set instance through lazy_static! managing kernel space

    +

    Fields§

    §__private_field: ()

    Trait Implementations§

    source§

    impl Deref for KERNEL_SPACE

    §

    type Target = Arc<UPSafeCell<MemorySet>, Global>

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &Arc<UPSafeCell<MemorySet>>

    Dereferences the value.
    source§

    impl LazyStatic for KERNEL_SPACE

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/memory_set/struct.MapArea.html b/ch5/os/mm/memory_set/struct.MapArea.html index f295f76d..25befb8c 100644 --- a/ch5/os/mm/memory_set/struct.MapArea.html +++ b/ch5/os/mm/memory_set/struct.MapArea.html @@ -1,20 +1,24 @@ -MapArea in os::mm::memory_set - Rust

    Struct os::mm::memory_set::MapArea

    source · [−]
    pub struct MapArea {
+MapArea in os::mm::memory_set - Rust
    Struct os::mm::memory_set::MapArea
    source · 
    pub struct MapArea {
     vpn_range: SimpleRange<VirtPageNum>,
     data_frames: BTreeMap<VirtPageNum, FrameTracker>,
     map_type: MapType,
     map_perm: MapPermission,
-}
    Expand description
    map area structure, controls a contiguous piece of virtual memory
    
-
    Fields
    vpn_range: SimpleRange<VirtPageNum>data_frames: BTreeMap<VirtPageNum, FrameTracker>map_type: MapTypemap_perm: MapPermission
    Implementations
    data: start-aligned but maybe with shorter length
+}
    Expand description

    map area structure, controls a contiguous piece of virtual memory

    +

    Fields§

    §vpn_range: SimpleRange<VirtPageNum>§data_frames: BTreeMap<VirtPageNum, FrameTracker>§map_type: MapType§map_perm: MapPermission

    Implementations§

    source§

    impl MapArea

    source

    pub fn new( + start_va: VirtAddr, + end_va: VirtAddr, + map_type: MapType, + map_perm: MapPermission +) -> Self

    source

    pub fn from_another(another: &Self) -> Self

    source

    pub fn map_one(&mut self, page_table: &mut PageTable, vpn: VirtPageNum)

    source

    pub fn unmap_one(&mut self, page_table: &mut PageTable, vpn: VirtPageNum)

    source

    pub fn map(&mut self, page_table: &mut PageTable)

    source

    pub fn unmap(&mut self, page_table: &mut PageTable)

    source

    pub fn copy_data(&mut self, page_table: &mut PageTable, data: &[u8])

    data: start-aligned but maybe with shorter length assume that all frames were cleared before

    -

    Auto Trait Implementations

    Blanket Implementations

    Gets the TypeId of self. Read more

    -

    Immutably borrows from an owned value. Read more

    -

    Mutably borrows from an owned value. Read more

    -

    Returns the argument unchanged.

    -

    Calls U::from(self).

    +

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/memory_set/struct.MapPermission.html b/ch5/os/mm/memory_set/struct.MapPermission.html index 9cf4e2d5..d4c434da 100644 --- a/ch5/os/mm/memory_set/struct.MapPermission.html +++ b/ch5/os/mm/memory_set/struct.MapPermission.html @@ -1,18 +1,18 @@ -MapPermission in os::mm::memory_set - Rust

    Struct os::mm::memory_set::MapPermission

    source · [−]
    pub struct MapPermission {
+MapPermission in os::mm::memory_set - Rust
    Struct os::mm::memory_set::MapPermission
    source · 
    pub struct MapPermission {
     bits: u8,
-}
    Expand description
    map permission corresponding to that in pte: R W X U
    
-
    Fields
    bits: u8
    Implementations
    Readable
    
-
    Writable
    
-
    Excutable
    
-
    Accessible in U mode
    
-
    Returns an empty set of flags.
    
-
    Returns the set containing all flags.
    
-
    Returns the raw value of the flags currently stored.
    
-
    Convert from underlying bit representation, unless that
+}
    Expand description

    map permission corresponding to that in pte: R W X U

    +

    Fields§

    §bits: u8

    Implementations§

    source§

    impl MapPermission

    source

    pub const R: Self = _

    Readable

    +
    source

    pub const W: Self = _

    Writable

    +
    source

    pub const X: Self = _

    Excutable

    +
    source

    pub const U: Self = _

    Accessible in U mode

    +
    source

    pub const fn empty() -> Self

    Returns an empty set of flags.

    +
    source

    pub const fn all() -> Self

    Returns the set containing all flags.

    +
    source

    pub const fn bits(&self) -> u8

    Returns the raw value of the flags currently stored.

    +
    source

    pub const fn from_bits(bits: u8) -> Option<Self>

    Convert from underlying bit representation, unless that representation contains bits that do not correspond to a flag.

    -

    Convert from underlying bit representation, dropping any bits +

    source

    pub const fn from_bits_truncate(bits: u8) -> Self

    Convert from underlying bit representation, dropping any bits that do not correspond to flags.

    -

    Convert from underlying bit representation, preserving all +

    source

    pub const unsafe fn from_bits_unchecked(bits: u8) -> Self

    Convert from underlying bit representation, preserving all bits (even those not corresponding to a defined flag).

    Safety

    The caller of the bitflags! macro can chose to allow or @@ -20,35 +20,35 @@ disallow extra bits for their bitflags type.

    The caller of from_bits_unchecked() has to ensure that all bits correspond to a defined flag or that extra bits are valid for this bitflags type.

    -

    Returns true if no flags are currently stored.

    -

    Returns true if all flags are currently set.

    -

    Returns true if there are flags common to both self and other.

    -

    Returns true if all of the flags in other are contained within self.

    -

    Inserts the specified flags in-place.

    -

    Removes the specified flags in-place.

    -

    Toggles the specified flags in-place.

    -

    Inserts or removes the specified flags depending on the passed value.

    -

    Returns the intersection between the flags in self and +

    source

    pub const fn is_empty(&self) -> bool

    Returns true if no flags are currently stored.

    +
    source

    pub const fn is_all(&self) -> bool

    Returns true if all flags are currently set.

    +
    source

    pub const fn intersects(&self, other: Self) -> bool

    Returns true if there are flags common to both self and other.

    +
    source

    pub const fn contains(&self, other: Self) -> bool

    Returns true if all of the flags in other are contained within self.

    +
    source

    pub fn insert(&mut self, other: Self)

    Inserts the specified flags in-place.

    +
    source

    pub fn remove(&mut self, other: Self)

    Removes the specified flags in-place.

    +
    source

    pub fn toggle(&mut self, other: Self)

    Toggles the specified flags in-place.

    +
    source

    pub fn set(&mut self, other: Self, value: bool)

    Inserts or removes the specified flags depending on the passed value.

    +
    source

    pub const fn intersection(self, other: Self) -> Self

    Returns the intersection between the flags in self and other.

    Specifically, the returned set contains only the flags which are present in both self and other.

    This is equivalent to using the & operator (e.g. ops::BitAnd), as in flags & other.

    -

    Returns the union of between the flags in self and other.

    +
    source

    pub const fn union(self, other: Self) -> Self

    Returns the union of between the flags in self and other.

    Specifically, the returned set contains all flags which are present in either self or other, including any which are -present in both (see Self::symmetric_difference if that +present in both (see Self::symmetric_difference if that is undesirable).

    This is equivalent to using the | operator (e.g. ops::BitOr), as in flags | other.

    -

    Returns the difference between the flags in self and other.

    +
    source

    pub const fn difference(self, other: Self) -> Self

    Returns the difference between the flags in self and other.

    Specifically, the returned set contains all flags present in self, except for the ones present in other.

    It is also conceptually equivalent to the “bit-clear” operation: flags & !other (and this syntax is also supported).

    This is equivalent to using the - operator (e.g. ops::Sub), as in flags - other.

    -

    Returns the symmetric difference between the flags +

    source

    pub const fn symmetric_difference(self, other: Self) -> Self

    Returns the symmetric difference between the flags in self and other.

    Specifically, the returned set contains the flags present which are present in self or other, but that are not present in @@ -56,66 +56,40 @@ both. Equivalently, it contains the flags present in exactly one of the sets self and other.

    This is equivalent to using the ^ operator (e.g. ops::BitXor), as in flags ^ other.

    -

    Returns the complement of this set of flags.

    +
    source

    pub const fn complement(self) -> Self

    Returns the complement of this set of flags.

    Specifically, the returned set contains all the flags which are not set in self, but which are allowed for this type.

    Alternatively, it can be thought of as the set difference -between Self::all() and self (e.g. Self::all() - self)

    +between Self::all() and self (e.g. Self::all() - self)

    This is equivalent to using the ! operator (e.g. ops::Not), as in !flags.

    -

    Trait Implementations

    Formats the value using the given formatter.

    -

    Returns the intersection between the two sets of flags.

    -

    The resulting type after applying the & operator.

    -

    Disables all flags disabled in the set.

    -

    Returns the union of the two sets of flags.

    -

    The resulting type after applying the | operator.

    -

    Adds the set of flags.

    -

    Returns the left flags, but with all the right flags toggled.

    -

    The resulting type after applying the ^ operator.

    -

    Toggles the set of flags.

    -

    Returns a copy of the value. Read more

    -

    Performs copy-assignment from source. Read more

    -

    Formats the value using the given formatter. Read more

    -

    Extends a collection with the contents of an iterator. Read more

    -
    🔬 This is a nightly-only experimental API. (extend_one)

    Extends a collection with exactly one element.

    -
    🔬 This is a nightly-only experimental API. (extend_one)

    Reserves capacity in a collection for the given number of additional elements. Read more

    -

    Creates a value from an iterator. Read more

    -

    Feeds this value into the given Hasher. Read more

    -

    Feeds a slice of this type into the given Hasher. Read more

    -

    Formats the value using the given formatter.

    -

    Returns the complement of this set of flags.

    -

    The resulting type after applying the ! operator.

    -

    Formats the value using the given formatter.

    -

    This method returns an Ordering between self and other. Read more

    -

    Compares and returns the maximum of two values. Read more

    -

    Compares and returns the minimum of two values. Read more

    -

    Restrict a value to a certain interval. Read more

    -

    This method tests for self and other values to be equal, and is used -by ==. Read more

    -

    This method tests for !=.

    -

    This method returns an ordering between self and other values if one exists. Read more

    -

    This method tests less than (for self and other) and is used by the < operator. Read more

    -

    This method tests less than or equal to (for self and other) and is used by the <= -operator. Read more

    -

    This method tests greater than (for self and other) and is used by the > operator. Read more

    -

    This method tests greater than or equal to (for self and other) and is used by the >= -operator. Read more

    -

    Returns the set difference of the two sets of flags.

    -

    The resulting type after applying the - operator.

    -

    Disables all flags enabled in the set.

    -

    Formats the value using the given formatter.

    -

    Auto Trait Implementations

    Blanket Implementations

    Gets the TypeId of self. Read more

    -

    Immutably borrows from an owned value. Read more

    -

    Mutably borrows from an owned value. Read more

    -

    Returns the argument unchanged.

    -

    Calls U::from(self).

    +

    Trait Implementations§

    source§

    impl Binary for MapPermission

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter.
    source§

    impl BitAnd<MapPermission> for MapPermission

    source§

    fn bitand(self, other: Self) -> Self

    Returns the intersection between the two sets of flags.

    +
    §

    type Output = MapPermission

    The resulting type after applying the & operator.
    source§

    impl BitAndAssign<MapPermission> for MapPermission

    source§

    fn bitand_assign(&mut self, other: Self)

    Disables all flags disabled in the set.

    +
    source§

    impl BitOr<MapPermission> for MapPermission

    source§

    fn bitor(self, other: MapPermission) -> Self

    Returns the union of the two sets of flags.

    +
    §

    type Output = MapPermission

    The resulting type after applying the | operator.
    source§

    impl BitOrAssign<MapPermission> for MapPermission

    source§

    fn bitor_assign(&mut self, other: Self)

    Adds the set of flags.

    +
    source§

    impl BitXor<MapPermission> for MapPermission

    source§

    fn bitxor(self, other: Self) -> Self

    Returns the left flags, but with all the right flags toggled.

    +
    §

    type Output = MapPermission

    The resulting type after applying the ^ operator.
    source§

    impl BitXorAssign<MapPermission> for MapPermission

    source§

    fn bitxor_assign(&mut self, other: Self)

    Toggles the set of flags.

    +
    source§

    impl Clone for MapPermission

    source§

    fn clone(&self) -> MapPermission

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for MapPermission

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl Extend<MapPermission> for MapPermission

    source§

    fn extend<T: IntoIterator<Item = Self>>(&mut self, iterator: T)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, item: A)

    🔬This is a nightly-only experimental API. (extend_one)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one)
    Reserves capacity in a collection for the given number of additional elements. Read more
    source§

    impl FromIterator<MapPermission> for MapPermission

    source§

    fn from_iter<T: IntoIterator<Item = Self>>(iterator: T) -> Self

    Creates a value from an iterator. Read more
    source§

    impl Hash for MapPermission

    source§

    fn hash<__H: Hasher>(&self, state: &mut __H)

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)where + H: Hasher, + Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    source§

    impl LowerHex for MapPermission

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter.
    source§

    impl Not for MapPermission

    source§

    fn not(self) -> Self

    Returns the complement of this set of flags.

    +
    §

    type Output = MapPermission

    The resulting type after applying the ! operator.
    source§

    impl Octal for MapPermission

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter.
    source§

    impl Ord for MapPermission

    source§

    fn cmp(&self, other: &MapPermission) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Selfwhere + Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Selfwhere + Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Selfwhere + Self: Sized + PartialOrd<Self>,

    Restrict a value to a certain interval. Read more
    source§

    impl PartialEq<MapPermission> for MapPermission

    source§

    fn eq(&self, other: &MapPermission) -> bool

    This method tests for self and other values to be equal, and is used +by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always +sufficient, and should not be overridden without very good reason.
    source§

    impl PartialOrd<MapPermission> for MapPermission

    source§

    fn partial_cmp(&self, other: &MapPermission) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    1.0.0 · source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    1.0.0 · source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= +operator. Read more
    1.0.0 · source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    1.0.0 · source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= +operator. Read more
    source§

    impl Sub<MapPermission> for MapPermission

    source§

    fn sub(self, other: Self) -> Self

    Returns the set difference of the two sets of flags.

    +
    §

    type Output = MapPermission

    The resulting type after applying the - operator.
    source§

    impl SubAssign<MapPermission> for MapPermission

    source§

    fn sub_assign(&mut self, other: Self)

    Disables all flags enabled in the set.

    +
    source§

    impl UpperHex for MapPermission

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter.
    source§

    impl Copy for MapPermission

    source§

    impl Eq for MapPermission

    source§

    impl StructuralEq for MapPermission

    source§

    impl StructuralPartialEq for MapPermission

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The resulting type after obtaining ownership.

    -

    Creates owned data from borrowed data, usually by cloning. Read more

    -

    Uses borrowed data to replace owned data, usually by cloning. Read more

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T> ToOwned for Twhere + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/memory_set/struct.MemorySet.html b/ch5/os/mm/memory_set/struct.MemorySet.html index 8da46fdf..5afb1bb3 100644 --- a/ch5/os/mm/memory_set/struct.MemorySet.html +++ b/ch5/os/mm/memory_set/struct.MemorySet.html @@ -1,28 +1,32 @@ -MemorySet in os::mm::memory_set - Rust

    Struct os::mm::memory_set::MemorySet

    source · [−]
    pub struct MemorySet {
+MemorySet in os::mm::memory_set - Rust
    Struct os::mm::memory_set::MemorySet
    source · 
    pub struct MemorySet {
     page_table: PageTable,
     areas: Vec<MapArea>,
-}
    Expand description
    memory set structure, controls virtual-memory space
    
-
    Fields
    page_table: PageTableareas: Vec<MapArea>
    Implementations
    Create an empty MemorySet
    
-
    Get pagetable root_ppn
    
-
    Assume that no conflicts.
    
-
    Remove MapArea that starts with start_vpn
    
-
    Mention that trampoline is not collected by areas.
    
-
    Without kernel stacks.
    
-
    Include sections in elf and trampoline and TrapContext and user stack,
+}
    Expand description

    memory set structure, controls virtual-memory space

    +

    Fields§

    §page_table: PageTable§areas: Vec<MapArea>

    Implementations§

    source§

    impl MemorySet

    source

    pub fn new_bare() -> Self

    Create an empty MemorySet

    +
    source

    pub fn token(&self) -> usize

    Get pagetable root_ppn

    +
    source

    pub fn insert_framed_area( + &mut self, + start_va: VirtAddr, + end_va: VirtAddr, + permission: MapPermission +)

    Assume that no conflicts.

    +
    source

    pub fn remove_area_with_start_vpn(&mut self, start_vpn: VirtPageNum)

    Remove MapArea that starts with start_vpn

    +
    source

    fn push(&mut self, map_area: MapArea, data: Option<&[u8]>)

    source

    fn map_trampoline(&mut self)

    Mention that trampoline is not collected by areas.

    +
    source

    pub fn new_kernel() -> Self

    Without kernel stacks.

    +
    source

    pub fn from_elf(elf_data: &[u8]) -> (Self, usize, usize)

    Include sections in elf and trampoline and TrapContext and user stack, also returns user_sp and entry point.

    -

    Clone a same MemorySet

    -

    Refresh TLB with sfence.vma

    -

    Translate throuth pagetable

    -

    Remove all MapArea

    -

    Auto Trait Implementations

    Blanket Implementations

    Gets the TypeId of self. Read more

    -

    Immutably borrows from an owned value. Read more

    -

    Mutably borrows from an owned value. Read more

    -

    Returns the argument unchanged.

    -

    Calls U::from(self).

    +
    source

    pub fn from_existed_user(user_space: &Self) -> Self

    Clone a same MemorySet

    +
    source

    pub fn activate(&self)

    Refresh TLB with sfence.vma

    +
    source

    pub fn translate(&self, vpn: VirtPageNum) -> Option<PageTableEntry>

    Translate throuth pagetable

    +
    source

    pub fn recycle_data_pages(&mut self)

    Remove all MapArea

    +

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/page_table/fn.translated_byte_buffer.html b/ch5/os/mm/page_table/fn.translated_byte_buffer.html index cb221bab..11709ad6 100644 --- a/ch5/os/mm/page_table/fn.translated_byte_buffer.html +++ b/ch5/os/mm/page_table/fn.translated_byte_buffer.html @@ -1,2 +1,6 @@ -translated_byte_buffer in os::mm::page_table - Rust

    Function os::mm::page_table::translated_byte_buffer

    source · [−]
    pub fn translated_byte_buffer(
        token: usize,
        ptr: *const u8,
        len: usize
    ) -> Vec<&'static mut [u8]>
    Expand description

    translate a pointer to a mutable u8 Vec through page table

    -
    \ No newline at end of file +translated_byte_buffer in os::mm::page_table - Rust

    Function os::mm::page_table::translated_byte_buffer

    source · 
    pub fn translated_byte_buffer(
+    token: usize,
+    ptr: *const u8,
+    len: usize
+) -> Vec<&'static mut [u8]>
    Expand description

    translate a pointer to a mutable u8 Vec through page table

    +
    \ No newline at end of file diff --git a/ch5/os/mm/page_table/fn.translated_refmut.html b/ch5/os/mm/page_table/fn.translated_refmut.html index c6d3792c..c1885f1b 100644 --- a/ch5/os/mm/page_table/fn.translated_refmut.html +++ b/ch5/os/mm/page_table/fn.translated_refmut.html @@ -1,2 +1,2 @@ -translated_refmut in os::mm::page_table - Rust

    Function os::mm::page_table::translated_refmut

    source · [−]
    pub fn translated_refmut<T>(token: usize, ptr: *mut T) -> &'static mut T
    Expand description

    translate a generic through page table and return a mutable reference

    -
    \ No newline at end of file +translated_refmut in os::mm::page_table - Rust

    Function os::mm::page_table::translated_refmut

    source · 
    pub fn translated_refmut<T>(token: usize, ptr: *mut T) -> &'static mut T
    Expand description

    translate a generic through page table and return a mutable reference

    +
    \ No newline at end of file diff --git a/ch5/os/mm/page_table/fn.translated_str.html b/ch5/os/mm/page_table/fn.translated_str.html index 20a57bc0..76799d94 100644 --- a/ch5/os/mm/page_table/fn.translated_str.html +++ b/ch5/os/mm/page_table/fn.translated_str.html @@ -1,2 +1,2 @@ -translated_str in os::mm::page_table - Rust

    Function os::mm::page_table::translated_str

    source · [−]
    pub fn translated_str(token: usize, ptr: *const u8) -> String
    Expand description

    translate a pointer to a mutable u8 Vec end with \0 through page table to a String

    -
    \ No newline at end of file +translated_str in os::mm::page_table - Rust

    Function os::mm::page_table::translated_str

    source · 
    pub fn translated_str(token: usize, ptr: *const u8) -> String
    Expand description

    translate a pointer to a mutable u8 Vec end with \0 through page table to a String

    +
    \ No newline at end of file diff --git a/ch5/os/mm/page_table/index.html b/ch5/os/mm/page_table/index.html index 50cbaa16..618aab4c 100644 --- a/ch5/os/mm/page_table/index.html +++ b/ch5/os/mm/page_table/index.html @@ -1,6 +1,2 @@ -os::mm::page_table - Rust

    Module os::mm::page_table

    source · [−]
    Expand description

    Implementation of PageTableEntry and PageTable.

    -

    Structs

    PTEFlags
    PageTable
    PageTableEntry

    page table entry structure

    -

    Functions

    translated_byte_buffer

    translate a pointer to a mutable u8 Vec through page table

    -
    translated_refmut

    translate a generic through page table and return a mutable reference

    -
    translated_str

    translate a pointer to a mutable u8 Vec end with \0 through page table to a String

    -
    \ No newline at end of file +os::mm::page_table - Rust

    Module os::mm::page_table

    source ·
    Expand description

    Implementation of PageTableEntry and PageTable.

    +

    Structs

    Functions

    \ No newline at end of file diff --git a/ch5/os/mm/page_table/sidebar-items.js b/ch5/os/mm/page_table/sidebar-items.js index 6e279f3c..8f39db9b 100644 --- a/ch5/os/mm/page_table/sidebar-items.js +++ b/ch5/os/mm/page_table/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"fn":[["translated_byte_buffer","translate a pointer to a mutable u8 Vec through page table"],["translated_refmut","translate a generic through page table and return a mutable reference"],["translated_str","translate a pointer to a mutable u8 Vec end with `\\0` through page table to a `String`"]],"struct":[["PTEFlags",""],["PageTable",""],["PageTableEntry","page table entry structure"]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"fn":["translated_byte_buffer","translated_refmut","translated_str"],"struct":["PTEFlags","PageTable","PageTableEntry"]}; \ No newline at end of file diff --git a/ch5/os/mm/page_table/struct.PTEFlags.html b/ch5/os/mm/page_table/struct.PTEFlags.html index 2825b544..4e6a2188 100644 --- a/ch5/os/mm/page_table/struct.PTEFlags.html +++ b/ch5/os/mm/page_table/struct.PTEFlags.html @@ -1,13 +1,13 @@ -PTEFlags in os::mm::page_table - Rust

    Struct os::mm::page_table::PTEFlags

    source · [−]
    pub struct PTEFlags {
+PTEFlags in os::mm::page_table - Rust
    Struct os::mm::page_table::PTEFlags
    source · 
    pub struct PTEFlags {
     bits: u8,
-}
    Fields
    bits: u8
    Implementations
    Returns an empty set of flags.
    
-
    Returns the set containing all flags.
    
-
    Returns the raw value of the flags currently stored.
    
-
    Convert from underlying bit representation, unless that
+}

    Fields§

    §bits: u8

    Implementations§

    source§

    impl PTEFlags

    source

    pub const V: Self = _

    source

    pub const R: Self = _

    source

    pub const W: Self = _

    source

    pub const X: Self = _

    source

    pub const U: Self = _

    source

    pub const G: Self = _

    source

    pub const A: Self = _

    source

    pub const D: Self = _

    source

    pub const fn empty() -> Self

    Returns an empty set of flags.

    +
    source

    pub const fn all() -> Self

    Returns the set containing all flags.

    +
    source

    pub const fn bits(&self) -> u8

    Returns the raw value of the flags currently stored.

    +
    source

    pub const fn from_bits(bits: u8) -> Option<Self>

    Convert from underlying bit representation, unless that representation contains bits that do not correspond to a flag.

    -

    Convert from underlying bit representation, dropping any bits +

    source

    pub const fn from_bits_truncate(bits: u8) -> Self

    Convert from underlying bit representation, dropping any bits that do not correspond to flags.

    -

    Convert from underlying bit representation, preserving all +

    source

    pub const unsafe fn from_bits_unchecked(bits: u8) -> Self

    Convert from underlying bit representation, preserving all bits (even those not corresponding to a defined flag).

    Safety

    The caller of the bitflags! macro can chose to allow or @@ -15,35 +15,35 @@ disallow extra bits for their bitflags type.

    The caller of from_bits_unchecked() has to ensure that all bits correspond to a defined flag or that extra bits are valid for this bitflags type.

    -

    Returns true if no flags are currently stored.

    -

    Returns true if all flags are currently set.

    -

    Returns true if there are flags common to both self and other.

    -

    Returns true if all of the flags in other are contained within self.

    -

    Inserts the specified flags in-place.

    -

    Removes the specified flags in-place.

    -

    Toggles the specified flags in-place.

    -

    Inserts or removes the specified flags depending on the passed value.

    -

    Returns the intersection between the flags in self and +

    source

    pub const fn is_empty(&self) -> bool

    Returns true if no flags are currently stored.

    +
    source

    pub const fn is_all(&self) -> bool

    Returns true if all flags are currently set.

    +
    source

    pub const fn intersects(&self, other: Self) -> bool

    Returns true if there are flags common to both self and other.

    +
    source

    pub const fn contains(&self, other: Self) -> bool

    Returns true if all of the flags in other are contained within self.

    +
    source

    pub fn insert(&mut self, other: Self)

    Inserts the specified flags in-place.

    +
    source

    pub fn remove(&mut self, other: Self)

    Removes the specified flags in-place.

    +
    source

    pub fn toggle(&mut self, other: Self)

    Toggles the specified flags in-place.

    +
    source

    pub fn set(&mut self, other: Self, value: bool)

    Inserts or removes the specified flags depending on the passed value.

    +
    source

    pub const fn intersection(self, other: Self) -> Self

    Returns the intersection between the flags in self and other.

    Specifically, the returned set contains only the flags which are present in both self and other.

    This is equivalent to using the & operator (e.g. ops::BitAnd), as in flags & other.

    -

    Returns the union of between the flags in self and other.

    +
    source

    pub const fn union(self, other: Self) -> Self

    Returns the union of between the flags in self and other.

    Specifically, the returned set contains all flags which are present in either self or other, including any which are -present in both (see Self::symmetric_difference if that +present in both (see Self::symmetric_difference if that is undesirable).

    This is equivalent to using the | operator (e.g. ops::BitOr), as in flags | other.

    -

    Returns the difference between the flags in self and other.

    +
    source

    pub const fn difference(self, other: Self) -> Self

    Returns the difference between the flags in self and other.

    Specifically, the returned set contains all flags present in self, except for the ones present in other.

    It is also conceptually equivalent to the “bit-clear” operation: flags & !other (and this syntax is also supported).

    This is equivalent to using the - operator (e.g. ops::Sub), as in flags - other.

    -

    Returns the symmetric difference between the flags +

    source

    pub const fn symmetric_difference(self, other: Self) -> Self

    Returns the symmetric difference between the flags in self and other.

    Specifically, the returned set contains the flags present which are present in self or other, but that are not present in @@ -51,66 +51,40 @@ both. Equivalently, it contains the flags present in exactly one of the sets self and other.

    This is equivalent to using the ^ operator (e.g. ops::BitXor), as in flags ^ other.

    -

    Returns the complement of this set of flags.

    +
    source

    pub const fn complement(self) -> Self

    Returns the complement of this set of flags.

    Specifically, the returned set contains all the flags which are not set in self, but which are allowed for this type.

    Alternatively, it can be thought of as the set difference -between Self::all() and self (e.g. Self::all() - self)

    +between Self::all() and self (e.g. Self::all() - self)

    This is equivalent to using the ! operator (e.g. ops::Not), as in !flags.

    -

    Trait Implementations

    Formats the value using the given formatter.

    -

    Returns the intersection between the two sets of flags.

    -

    The resulting type after applying the & operator.

    -

    Disables all flags disabled in the set.

    -

    Returns the union of the two sets of flags.

    -

    The resulting type after applying the | operator.

    -

    Adds the set of flags.

    -

    Returns the left flags, but with all the right flags toggled.

    -

    The resulting type after applying the ^ operator.

    -

    Toggles the set of flags.

    -

    Returns a copy of the value. Read more

    -

    Performs copy-assignment from source. Read more

    -

    Formats the value using the given formatter. Read more

    -

    Extends a collection with the contents of an iterator. Read more

    -
    🔬 This is a nightly-only experimental API. (extend_one)

    Extends a collection with exactly one element.

    -
    🔬 This is a nightly-only experimental API. (extend_one)

    Reserves capacity in a collection for the given number of additional elements. Read more

    -

    Creates a value from an iterator. Read more

    -

    Feeds this value into the given Hasher. Read more

    -

    Feeds a slice of this type into the given Hasher. Read more

    -

    Formats the value using the given formatter.

    -

    Returns the complement of this set of flags.

    -

    The resulting type after applying the ! operator.

    -

    Formats the value using the given formatter.

    -

    This method returns an Ordering between self and other. Read more

    -

    Compares and returns the maximum of two values. Read more

    -

    Compares and returns the minimum of two values. Read more

    -

    Restrict a value to a certain interval. Read more

    -

    This method tests for self and other values to be equal, and is used -by ==. Read more

    -

    This method tests for !=.

    -

    This method returns an ordering between self and other values if one exists. Read more

    -

    This method tests less than (for self and other) and is used by the < operator. Read more

    -

    This method tests less than or equal to (for self and other) and is used by the <= -operator. Read more

    -

    This method tests greater than (for self and other) and is used by the > operator. Read more

    -

    This method tests greater than or equal to (for self and other) and is used by the >= -operator. Read more

    -

    Returns the set difference of the two sets of flags.

    -

    The resulting type after applying the - operator.

    -

    Disables all flags enabled in the set.

    -

    Formats the value using the given formatter.

    -

    Auto Trait Implementations

    Blanket Implementations

    Gets the TypeId of self. Read more

    -

    Immutably borrows from an owned value. Read more

    -

    Mutably borrows from an owned value. Read more

    -

    Returns the argument unchanged.

    -

    Calls U::from(self).

    +

    Trait Implementations§

    source§

    impl Binary for PTEFlags

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter.
    source§

    impl BitAnd<PTEFlags> for PTEFlags

    source§

    fn bitand(self, other: Self) -> Self

    Returns the intersection between the two sets of flags.

    +
    §

    type Output = PTEFlags

    The resulting type after applying the & operator.
    source§

    impl BitAndAssign<PTEFlags> for PTEFlags

    source§

    fn bitand_assign(&mut self, other: Self)

    Disables all flags disabled in the set.

    +
    source§

    impl BitOr<PTEFlags> for PTEFlags

    source§

    fn bitor(self, other: PTEFlags) -> Self

    Returns the union of the two sets of flags.

    +
    §

    type Output = PTEFlags

    The resulting type after applying the | operator.
    source§

    impl BitOrAssign<PTEFlags> for PTEFlags

    source§

    fn bitor_assign(&mut self, other: Self)

    Adds the set of flags.

    +
    source§

    impl BitXor<PTEFlags> for PTEFlags

    source§

    fn bitxor(self, other: Self) -> Self

    Returns the left flags, but with all the right flags toggled.

    +
    §

    type Output = PTEFlags

    The resulting type after applying the ^ operator.
    source§

    impl BitXorAssign<PTEFlags> for PTEFlags

    source§

    fn bitxor_assign(&mut self, other: Self)

    Toggles the set of flags.

    +
    source§

    impl Clone for PTEFlags

    source§

    fn clone(&self) -> PTEFlags

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for PTEFlags

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl Extend<PTEFlags> for PTEFlags

    source§

    fn extend<T: IntoIterator<Item = Self>>(&mut self, iterator: T)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, item: A)

    🔬This is a nightly-only experimental API. (extend_one)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one)
    Reserves capacity in a collection for the given number of additional elements. Read more
    source§

    impl FromIterator<PTEFlags> for PTEFlags

    source§

    fn from_iter<T: IntoIterator<Item = Self>>(iterator: T) -> Self

    Creates a value from an iterator. Read more
    source§

    impl Hash for PTEFlags

    source§

    fn hash<__H: Hasher>(&self, state: &mut __H)

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)where + H: Hasher, + Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    source§

    impl LowerHex for PTEFlags

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter.
    source§

    impl Not for PTEFlags

    source§

    fn not(self) -> Self

    Returns the complement of this set of flags.

    +
    §

    type Output = PTEFlags

    The resulting type after applying the ! operator.
    source§

    impl Octal for PTEFlags

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter.
    source§

    impl Ord for PTEFlags

    source§

    fn cmp(&self, other: &PTEFlags) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Selfwhere + Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Selfwhere + Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Selfwhere + Self: Sized + PartialOrd<Self>,

    Restrict a value to a certain interval. Read more
    source§

    impl PartialEq<PTEFlags> for PTEFlags

    source§

    fn eq(&self, other: &PTEFlags) -> bool

    This method tests for self and other values to be equal, and is used +by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always +sufficient, and should not be overridden without very good reason.
    source§

    impl PartialOrd<PTEFlags> for PTEFlags

    source§

    fn partial_cmp(&self, other: &PTEFlags) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    1.0.0 · source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    1.0.0 · source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= +operator. Read more
    1.0.0 · source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    1.0.0 · source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= +operator. Read more
    source§

    impl Sub<PTEFlags> for PTEFlags

    source§

    fn sub(self, other: Self) -> Self

    Returns the set difference of the two sets of flags.

    +
    §

    type Output = PTEFlags

    The resulting type after applying the - operator.
    source§

    impl SubAssign<PTEFlags> for PTEFlags

    source§

    fn sub_assign(&mut self, other: Self)

    Disables all flags enabled in the set.

    +
    source§

    impl UpperHex for PTEFlags

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter.
    source§

    impl Copy for PTEFlags

    source§

    impl Eq for PTEFlags

    source§

    impl StructuralEq for PTEFlags

    source§

    impl StructuralPartialEq for PTEFlags

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The resulting type after obtaining ownership.

    -

    Creates owned data from borrowed data, usually by cloning. Read more

    -

    Uses borrowed data to replace owned data, usually by cloning. Read more

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T> ToOwned for Twhere + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/page_table/struct.PageTable.html b/ch5/os/mm/page_table/struct.PageTable.html index bc522631..a56c0672 100644 --- a/ch5/os/mm/page_table/struct.PageTable.html +++ b/ch5/os/mm/page_table/struct.PageTable.html @@ -1,17 +1,16 @@ -PageTable in os::mm::page_table - Rust

    Struct os::mm::page_table::PageTable

    source · [−]
    pub struct PageTable {
+PageTable in os::mm::page_table - Rust
    Struct os::mm::page_table::PageTable
    source · 
    pub struct PageTable {
     root_ppn: PhysPageNum,
     frames: Vec<FrameTracker>,
-}
    Fields
    root_ppn: PhysPageNumframes: Vec<FrameTracker>
    Implementations
    Assume that it won’t oom when creating/mapping.
    
-
    Temporarily used to get arguments from user space.
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}

    Fields§

    §root_ppn: PhysPageNum§frames: Vec<FrameTracker>

    Implementations§

    source§

    impl PageTable

    Assume that it won’t oom when creating/mapping.

    +
    source

    pub fn new() -> Self

    source

    pub fn from_token(satp: usize) -> Self

    Temporarily used to get arguments from user space.

    +
    source

    fn find_pte_create(&mut self, vpn: VirtPageNum) -> Option<&mut PageTableEntry>

    source

    fn find_pte(&self, vpn: VirtPageNum) -> Option<&mut PageTableEntry>

    source

    pub fn map(&mut self, vpn: VirtPageNum, ppn: PhysPageNum, flags: PTEFlags)

    source

    pub fn unmap(&mut self, vpn: VirtPageNum)

    source

    pub fn translate(&self, vpn: VirtPageNum) -> Option<PageTableEntry>

    source

    pub fn translate_va(&self, va: VirtAddr) -> Option<PhysAddr>

    source

    pub fn token(&self) -> usize

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/page_table/struct.PageTableEntry.html b/ch5/os/mm/page_table/struct.PageTableEntry.html index 848a76cb..dae19078 100644 --- a/ch5/os/mm/page_table/struct.PageTableEntry.html +++ b/ch5/os/mm/page_table/struct.PageTableEntry.html @@ -1,29 +1,24 @@ -PageTableEntry in os::mm::page_table - Rust

    Struct os::mm::page_table::PageTableEntry

    source · [−]
    #[repr(C)]
    pub struct PageTableEntry {
+PageTableEntry in os::mm::page_table - Rust
    Struct os::mm::page_table::PageTableEntry
    source · 
    #[repr(C)]
    pub struct PageTableEntry {
     pub bits: usize,
-}
    Expand description
    page table entry structure
    
-
    Fields
    bits: usize
    PTE
    
-
    Implementations
    Create a PTE from ppn
    
-
    Return an empty PTE
    
-
    Return 44bit ppn
    
-
    Return 10bit flag
    
-
    Check PTE valid
    
-
    Check PTE readable
    
-
    Check PTE writable
    
-
    Check PTE executable
    
-
    Trait Implementations
    Returns a copy of the value. Read more
    
-
    Performs copy-assignment from source. Read more
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}
    Expand description

    page table entry structure

    +

    Fields§

    §bits: usize

    PTE

    +

    Implementations§

    source§

    impl PageTableEntry

    source

    pub fn new(ppn: PhysPageNum, flags: PTEFlags) -> Self

    Create a PTE from ppn

    +
    source

    pub fn empty() -> Self

    Return an empty PTE

    +
    source

    pub fn ppn(&self) -> PhysPageNum

    Return 44bit ppn

    +
    source

    pub fn flags(&self) -> PTEFlags

    Return 10bit flag

    +
    source

    pub fn is_valid(&self) -> bool

    Check PTE valid

    +
    source

    pub fn readable(&self) -> bool

    Check PTE readable

    +
    source

    pub fn writable(&self) -> bool

    Check PTE writable

    +
    source

    pub fn executable(&self) -> bool

    Check PTE executable

    +

    Trait Implementations§

    source§

    impl Clone for PageTableEntry

    source§

    fn clone(&self) -> PageTableEntry

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Copy for PageTableEntry

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The resulting type after obtaining ownership.

    -

    Creates owned data from borrowed data, usually by cloning. Read more

    -

    Uses borrowed data to replace owned data, usually by cloning. Read more

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T> ToOwned for Twhere + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/sidebar-items.js b/ch5/os/mm/sidebar-items.js index b8b598cd..2b56b532 100644 --- a/ch5/os/mm/sidebar-items.js +++ b/ch5/os/mm/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"fn":[["frame_alloc","allocate a frame"],["init","initiate heap allocator, frame allocator and kernel space"],["remap_test","Check PageTable running correctly"],["translated_byte_buffer","translate a pointer to a mutable u8 Vec through page table"],["translated_refmut","translate a generic through page table and return a mutable reference"],["translated_str","translate a pointer to a mutable u8 Vec end with `\\0` through page table to a `String`"]],"mod":[["address","Implementation of physical and virtual address and page number."],["frame_allocator","Implementation of [`FrameAllocator`] which controls all the frames in the operating system."],["heap_allocator","The global allocator"],["memory_set","Implementation of [`MapArea`] and [`MemorySet`]."],["page_table","Implementation of [`PageTableEntry`] and [`PageTable`]."]],"struct":[["FrameTracker","manage a frame which has the same lifecycle as the tracker"],["KERNEL_SPACE","a memory set instance through lazy_static! managing kernel space"],["MapPermission","map permission corresponding to that in pte: `R W X U`"],["MemorySet","memory set structure, controls virtual-memory space"],["PageTableEntry","page table entry structure"],["PhysAddr","physical address"],["PhysPageNum","physical page number"],["VirtAddr","virtual address"],["VirtPageNum","virtual page number"]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"fn":["frame_alloc","init","remap_test","translated_byte_buffer","translated_refmut","translated_str"],"mod":["address","frame_allocator","heap_allocator","memory_set","page_table"],"struct":["FrameTracker","KERNEL_SPACE","MapPermission","MemorySet","PageTableEntry","PhysAddr","PhysPageNum","VirtAddr","VirtPageNum"]}; \ No newline at end of file diff --git a/ch5/os/mm/struct.FrameTracker.html b/ch5/os/mm/struct.FrameTracker.html index 324e5f0e..14b40bfc 100644 --- a/ch5/os/mm/struct.FrameTracker.html +++ b/ch5/os/mm/struct.FrameTracker.html @@ -1,18 +1,15 @@ -FrameTracker in os::mm - Rust

    Struct os::mm::FrameTracker

    source · [−]
    pub struct FrameTracker {
+FrameTracker in os::mm - Rust
    Struct os::mm::FrameTracker
    source · 
    pub struct FrameTracker {
     pub ppn: PhysPageNum,
-}
    Expand description
    manage a frame which has the same lifecycle as the tracker
    
-
    Fields
    ppn: PhysPageNum
    Implementations
    Create an empty FrameTracker
    
-
    Trait Implementations
    Formats the value using the given formatter. Read more
    
-
    Executes the destructor for this type. Read more
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}
    Expand description

    manage a frame which has the same lifecycle as the tracker

    +

    Fields§

    §ppn: PhysPageNum

    Implementations§

    source§

    impl FrameTracker

    source

    pub fn new(ppn: PhysPageNum) -> Self

    Create an empty FrameTracker

    +

    Trait Implementations§

    source§

    impl Debug for FrameTracker

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl Drop for FrameTracker

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/struct.KERNEL_SPACE.html b/ch5/os/mm/struct.KERNEL_SPACE.html index 50065481..a3cc6b59 100644 --- a/ch5/os/mm/struct.KERNEL_SPACE.html +++ b/ch5/os/mm/struct.KERNEL_SPACE.html @@ -1,17 +1,14 @@ -KERNEL_SPACE in os::mm - Rust

    Struct os::mm::KERNEL_SPACE

    source · [−]
    pub struct KERNEL_SPACE {
+KERNEL_SPACE in os::mm - Rust
    Struct os::mm::KERNEL_SPACE
    source · 
    pub struct KERNEL_SPACE {
     __private_field: (),
-}
    Expand description
    a memory set instance through lazy_static! managing kernel space
    
-
    Fields
    __private_field: ()
    Trait Implementations
    The resulting type after dereferencing.
    
-
    Dereferences the value.
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}
    Expand description

    a memory set instance through lazy_static! managing kernel space

    +

    Fields§

    §__private_field: ()

    Trait Implementations§

    source§

    impl Deref for KERNEL_SPACE

    §

    type Target = Arc<UPSafeCell<MemorySet>, Global>

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &Arc<UPSafeCell<MemorySet>>

    Dereferences the value.
    source§

    impl LazyStatic for KERNEL_SPACE

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/struct.MapPermission.html b/ch5/os/mm/struct.MapPermission.html index d276c98e..e32a1fce 100644 --- a/ch5/os/mm/struct.MapPermission.html +++ b/ch5/os/mm/struct.MapPermission.html @@ -1,18 +1,18 @@ -MapPermission in os::mm - Rust

    Struct os::mm::MapPermission

    source · [−]
    pub struct MapPermission {
+MapPermission in os::mm - Rust
    Struct os::mm::MapPermission
    source · 
    pub struct MapPermission {
     bits: u8,
-}
    Expand description
    map permission corresponding to that in pte: R W X U
    
-
    Fields
    bits: u8
    Implementations
    Readable
    
-
    Writable
    
-
    Excutable
    
-
    Accessible in U mode
    
-
    Returns an empty set of flags.
    
-
    Returns the set containing all flags.
    
-
    Returns the raw value of the flags currently stored.
    
-
    Convert from underlying bit representation, unless that
+}
    Expand description

    map permission corresponding to that in pte: R W X U

    +

    Fields§

    §bits: u8

    Implementations§

    source§

    impl MapPermission

    source

    pub const R: Self = _

    Readable

    +
    source

    pub const W: Self = _

    Writable

    +
    source

    pub const X: Self = _

    Excutable

    +
    source

    pub const U: Self = _

    Accessible in U mode

    +
    source

    pub const fn empty() -> Self

    Returns an empty set of flags.

    +
    source

    pub const fn all() -> Self

    Returns the set containing all flags.

    +
    source

    pub const fn bits(&self) -> u8

    Returns the raw value of the flags currently stored.

    +
    source

    pub const fn from_bits(bits: u8) -> Option<Self>

    Convert from underlying bit representation, unless that representation contains bits that do not correspond to a flag.

    -

    Convert from underlying bit representation, dropping any bits +

    source

    pub const fn from_bits_truncate(bits: u8) -> Self

    Convert from underlying bit representation, dropping any bits that do not correspond to flags.

    -

    Convert from underlying bit representation, preserving all +

    source

    pub const unsafe fn from_bits_unchecked(bits: u8) -> Self

    Convert from underlying bit representation, preserving all bits (even those not corresponding to a defined flag).

    Safety

    The caller of the bitflags! macro can chose to allow or @@ -20,35 +20,35 @@ disallow extra bits for their bitflags type.

    The caller of from_bits_unchecked() has to ensure that all bits correspond to a defined flag or that extra bits are valid for this bitflags type.

    -

    Returns true if no flags are currently stored.

    -

    Returns true if all flags are currently set.

    -

    Returns true if there are flags common to both self and other.

    -

    Returns true if all of the flags in other are contained within self.

    -

    Inserts the specified flags in-place.

    -

    Removes the specified flags in-place.

    -

    Toggles the specified flags in-place.

    -

    Inserts or removes the specified flags depending on the passed value.

    -

    Returns the intersection between the flags in self and +

    source

    pub const fn is_empty(&self) -> bool

    Returns true if no flags are currently stored.

    +
    source

    pub const fn is_all(&self) -> bool

    Returns true if all flags are currently set.

    +
    source

    pub const fn intersects(&self, other: Self) -> bool

    Returns true if there are flags common to both self and other.

    +
    source

    pub const fn contains(&self, other: Self) -> bool

    Returns true if all of the flags in other are contained within self.

    +
    source

    pub fn insert(&mut self, other: Self)

    Inserts the specified flags in-place.

    +
    source

    pub fn remove(&mut self, other: Self)

    Removes the specified flags in-place.

    +
    source

    pub fn toggle(&mut self, other: Self)

    Toggles the specified flags in-place.

    +
    source

    pub fn set(&mut self, other: Self, value: bool)

    Inserts or removes the specified flags depending on the passed value.

    +
    source

    pub const fn intersection(self, other: Self) -> Self

    Returns the intersection between the flags in self and other.

    Specifically, the returned set contains only the flags which are present in both self and other.

    This is equivalent to using the & operator (e.g. ops::BitAnd), as in flags & other.

    -

    Returns the union of between the flags in self and other.

    +
    source

    pub const fn union(self, other: Self) -> Self

    Returns the union of between the flags in self and other.

    Specifically, the returned set contains all flags which are present in either self or other, including any which are -present in both (see Self::symmetric_difference if that +present in both (see Self::symmetric_difference if that is undesirable).

    This is equivalent to using the | operator (e.g. ops::BitOr), as in flags | other.

    -

    Returns the difference between the flags in self and other.

    +
    source

    pub const fn difference(self, other: Self) -> Self

    Returns the difference between the flags in self and other.

    Specifically, the returned set contains all flags present in self, except for the ones present in other.

    It is also conceptually equivalent to the “bit-clear” operation: flags & !other (and this syntax is also supported).

    This is equivalent to using the - operator (e.g. ops::Sub), as in flags - other.

    -

    Returns the symmetric difference between the flags +

    source

    pub const fn symmetric_difference(self, other: Self) -> Self

    Returns the symmetric difference between the flags in self and other.

    Specifically, the returned set contains the flags present which are present in self or other, but that are not present in @@ -56,66 +56,40 @@ both. Equivalently, it contains the flags present in exactly one of the sets self and other.

    This is equivalent to using the ^ operator (e.g. ops::BitXor), as in flags ^ other.

    -

    Returns the complement of this set of flags.

    +
    source

    pub const fn complement(self) -> Self

    Returns the complement of this set of flags.

    Specifically, the returned set contains all the flags which are not set in self, but which are allowed for this type.

    Alternatively, it can be thought of as the set difference -between Self::all() and self (e.g. Self::all() - self)

    +between Self::all() and self (e.g. Self::all() - self)

    This is equivalent to using the ! operator (e.g. ops::Not), as in !flags.

    -

    Trait Implementations

    Formats the value using the given formatter.

    -

    Returns the intersection between the two sets of flags.

    -

    The resulting type after applying the & operator.

    -

    Disables all flags disabled in the set.

    -

    Returns the union of the two sets of flags.

    -

    The resulting type after applying the | operator.

    -

    Adds the set of flags.

    -

    Returns the left flags, but with all the right flags toggled.

    -

    The resulting type after applying the ^ operator.

    -

    Toggles the set of flags.

    -

    Returns a copy of the value. Read more

    -

    Performs copy-assignment from source. Read more

    -

    Formats the value using the given formatter. Read more

    -

    Extends a collection with the contents of an iterator. Read more

    -
    🔬 This is a nightly-only experimental API. (extend_one)

    Extends a collection with exactly one element.

    -
    🔬 This is a nightly-only experimental API. (extend_one)

    Reserves capacity in a collection for the given number of additional elements. Read more

    -

    Creates a value from an iterator. Read more

    -

    Feeds this value into the given Hasher. Read more

    -

    Feeds a slice of this type into the given Hasher. Read more

    -

    Formats the value using the given formatter.

    -

    Returns the complement of this set of flags.

    -

    The resulting type after applying the ! operator.

    -

    Formats the value using the given formatter.

    -

    This method returns an Ordering between self and other. Read more

    -

    Compares and returns the maximum of two values. Read more

    -

    Compares and returns the minimum of two values. Read more

    -

    Restrict a value to a certain interval. Read more

    -

    This method tests for self and other values to be equal, and is used -by ==. Read more

    -

    This method tests for !=.

    -

    This method returns an ordering between self and other values if one exists. Read more

    -

    This method tests less than (for self and other) and is used by the < operator. Read more

    -

    This method tests less than or equal to (for self and other) and is used by the <= -operator. Read more

    -

    This method tests greater than (for self and other) and is used by the > operator. Read more

    -

    This method tests greater than or equal to (for self and other) and is used by the >= -operator. Read more

    -

    Returns the set difference of the two sets of flags.

    -

    The resulting type after applying the - operator.

    -

    Disables all flags enabled in the set.

    -

    Formats the value using the given formatter.

    -

    Auto Trait Implementations

    Blanket Implementations

    Gets the TypeId of self. Read more

    -

    Immutably borrows from an owned value. Read more

    -

    Mutably borrows from an owned value. Read more

    -

    Returns the argument unchanged.

    -

    Calls U::from(self).

    +

    Trait Implementations§

    source§

    impl Binary for MapPermission

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter.
    source§

    impl BitAnd<MapPermission> for MapPermission

    source§

    fn bitand(self, other: Self) -> Self

    Returns the intersection between the two sets of flags.

    +
    §

    type Output = MapPermission

    The resulting type after applying the & operator.
    source§

    impl BitAndAssign<MapPermission> for MapPermission

    source§

    fn bitand_assign(&mut self, other: Self)

    Disables all flags disabled in the set.

    +
    source§

    impl BitOr<MapPermission> for MapPermission

    source§

    fn bitor(self, other: MapPermission) -> Self

    Returns the union of the two sets of flags.

    +
    §

    type Output = MapPermission

    The resulting type after applying the | operator.
    source§

    impl BitOrAssign<MapPermission> for MapPermission

    source§

    fn bitor_assign(&mut self, other: Self)

    Adds the set of flags.

    +
    source§

    impl BitXor<MapPermission> for MapPermission

    source§

    fn bitxor(self, other: Self) -> Self

    Returns the left flags, but with all the right flags toggled.

    +
    §

    type Output = MapPermission

    The resulting type after applying the ^ operator.
    source§

    impl BitXorAssign<MapPermission> for MapPermission

    source§

    fn bitxor_assign(&mut self, other: Self)

    Toggles the set of flags.

    +
    source§

    impl Clone for MapPermission

    source§

    fn clone(&self) -> MapPermission

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for MapPermission

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl Extend<MapPermission> for MapPermission

    source§

    fn extend<T: IntoIterator<Item = Self>>(&mut self, iterator: T)

    Extends a collection with the contents of an iterator. Read more
    source§

    fn extend_one(&mut self, item: A)

    🔬This is a nightly-only experimental API. (extend_one)
    Extends a collection with exactly one element.
    source§

    fn extend_reserve(&mut self, additional: usize)

    🔬This is a nightly-only experimental API. (extend_one)
    Reserves capacity in a collection for the given number of additional elements. Read more
    source§

    impl FromIterator<MapPermission> for MapPermission

    source§

    fn from_iter<T: IntoIterator<Item = Self>>(iterator: T) -> Self

    Creates a value from an iterator. Read more
    source§

    impl Hash for MapPermission

    source§

    fn hash<__H: Hasher>(&self, state: &mut __H)

    Feeds this value into the given Hasher. Read more
    1.3.0 · source§

    fn hash_slice<H>(data: &[Self], state: &mut H)where + H: Hasher, + Self: Sized,

    Feeds a slice of this type into the given Hasher. Read more
    source§

    impl LowerHex for MapPermission

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter.
    source§

    impl Not for MapPermission

    source§

    fn not(self) -> Self

    Returns the complement of this set of flags.

    +
    §

    type Output = MapPermission

    The resulting type after applying the ! operator.
    source§

    impl Octal for MapPermission

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter.
    source§

    impl Ord for MapPermission

    source§

    fn cmp(&self, other: &MapPermission) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Selfwhere + Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Selfwhere + Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Selfwhere + Self: Sized + PartialOrd<Self>,

    Restrict a value to a certain interval. Read more
    source§

    impl PartialEq<MapPermission> for MapPermission

    source§

    fn eq(&self, other: &MapPermission) -> bool

    This method tests for self and other values to be equal, and is used +by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always +sufficient, and should not be overridden without very good reason.
    source§

    impl PartialOrd<MapPermission> for MapPermission

    source§

    fn partial_cmp(&self, other: &MapPermission) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    1.0.0 · source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    1.0.0 · source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= +operator. Read more
    1.0.0 · source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    1.0.0 · source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= +operator. Read more
    source§

    impl Sub<MapPermission> for MapPermission

    source§

    fn sub(self, other: Self) -> Self

    Returns the set difference of the two sets of flags.

    +
    §

    type Output = MapPermission

    The resulting type after applying the - operator.
    source§

    impl SubAssign<MapPermission> for MapPermission

    source§

    fn sub_assign(&mut self, other: Self)

    Disables all flags enabled in the set.

    +
    source§

    impl UpperHex for MapPermission

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter.
    source§

    impl Copy for MapPermission

    source§

    impl Eq for MapPermission

    source§

    impl StructuralEq for MapPermission

    source§

    impl StructuralPartialEq for MapPermission

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The resulting type after obtaining ownership.

    -

    Creates owned data from borrowed data, usually by cloning. Read more

    -

    Uses borrowed data to replace owned data, usually by cloning. Read more

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T> ToOwned for Twhere + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/struct.MemorySet.html b/ch5/os/mm/struct.MemorySet.html index 7013927d..027baf01 100644 --- a/ch5/os/mm/struct.MemorySet.html +++ b/ch5/os/mm/struct.MemorySet.html @@ -1,28 +1,32 @@ -MemorySet in os::mm - Rust

    Struct os::mm::MemorySet

    source · [−]
    pub struct MemorySet {
+MemorySet in os::mm - Rust
    Struct os::mm::MemorySet
    source · 
    pub struct MemorySet {
     page_table: PageTable,
     areas: Vec<MapArea>,
-}
    Expand description
    memory set structure, controls virtual-memory space
    
-
    Fields
    page_table: PageTableareas: Vec<MapArea>
    Implementations
    Create an empty MemorySet
    
-
    Get pagetable root_ppn
    
-
    Assume that no conflicts.
    
-
    Remove MapArea that starts with start_vpn
    
-
    Mention that trampoline is not collected by areas.
    
-
    Without kernel stacks.
    
-
    Include sections in elf and trampoline and TrapContext and user stack,
+}
    Expand description

    memory set structure, controls virtual-memory space

    +

    Fields§

    §page_table: PageTable§areas: Vec<MapArea>

    Implementations§

    source§

    impl MemorySet

    source

    pub fn new_bare() -> Self

    Create an empty MemorySet

    +
    source

    pub fn token(&self) -> usize

    Get pagetable root_ppn

    +
    source

    pub fn insert_framed_area( + &mut self, + start_va: VirtAddr, + end_va: VirtAddr, + permission: MapPermission +)

    Assume that no conflicts.

    +
    source

    pub fn remove_area_with_start_vpn(&mut self, start_vpn: VirtPageNum)

    Remove MapArea that starts with start_vpn

    +
    source

    fn push(&mut self, map_area: MapArea, data: Option<&[u8]>)

    source

    fn map_trampoline(&mut self)

    Mention that trampoline is not collected by areas.

    +
    source

    pub fn new_kernel() -> Self

    Without kernel stacks.

    +
    source

    pub fn from_elf(elf_data: &[u8]) -> (Self, usize, usize)

    Include sections in elf and trampoline and TrapContext and user stack, also returns user_sp and entry point.

    -

    Clone a same MemorySet

    -

    Refresh TLB with sfence.vma

    -

    Translate throuth pagetable

    -

    Remove all MapArea

    -

    Auto Trait Implementations

    Blanket Implementations

    Gets the TypeId of self. Read more

    -

    Immutably borrows from an owned value. Read more

    -

    Mutably borrows from an owned value. Read more

    -

    Returns the argument unchanged.

    -

    Calls U::from(self).

    +
    source

    pub fn from_existed_user(user_space: &Self) -> Self

    Clone a same MemorySet

    +
    source

    pub fn activate(&self)

    Refresh TLB with sfence.vma

    +
    source

    pub fn translate(&self, vpn: VirtPageNum) -> Option<PageTableEntry>

    Translate throuth pagetable

    +
    source

    pub fn recycle_data_pages(&mut self)

    Remove all MapArea

    +

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/struct.PageTableEntry.html b/ch5/os/mm/struct.PageTableEntry.html index 52b02fae..57700eac 100644 --- a/ch5/os/mm/struct.PageTableEntry.html +++ b/ch5/os/mm/struct.PageTableEntry.html @@ -1,29 +1,24 @@ -PageTableEntry in os::mm - Rust

    Struct os::mm::PageTableEntry

    source · [−]
    #[repr(C)]
    pub struct PageTableEntry {
+PageTableEntry in os::mm - Rust
    Struct os::mm::PageTableEntry
    source · 
    #[repr(C)]
    pub struct PageTableEntry {
     pub bits: usize,
-}
    Expand description
    page table entry structure
    
-
    Fields
    bits: usize
    PTE
    
-
    Implementations
    Create a PTE from ppn
    
-
    Return an empty PTE
    
-
    Return 44bit ppn
    
-
    Return 10bit flag
    
-
    Check PTE valid
    
-
    Check PTE readable
    
-
    Check PTE writable
    
-
    Check PTE executable
    
-
    Trait Implementations
    Returns a copy of the value. Read more
    
-
    Performs copy-assignment from source. Read more
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}
    Expand description

    page table entry structure

    +

    Fields§

    §bits: usize

    PTE

    +

    Implementations§

    source§

    impl PageTableEntry

    source

    pub fn new(ppn: PhysPageNum, flags: PTEFlags) -> Self

    Create a PTE from ppn

    +
    source

    pub fn empty() -> Self

    Return an empty PTE

    +
    source

    pub fn ppn(&self) -> PhysPageNum

    Return 44bit ppn

    +
    source

    pub fn flags(&self) -> PTEFlags

    Return 10bit flag

    +
    source

    pub fn is_valid(&self) -> bool

    Check PTE valid

    +
    source

    pub fn readable(&self) -> bool

    Check PTE readable

    +
    source

    pub fn writable(&self) -> bool

    Check PTE writable

    +
    source

    pub fn executable(&self) -> bool

    Check PTE executable

    +

    Trait Implementations§

    source§

    impl Clone for PageTableEntry

    source§

    fn clone(&self) -> PageTableEntry

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Copy for PageTableEntry

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The resulting type after obtaining ownership.

    -

    Creates owned data from borrowed data, usually by cloning. Read more

    -

    Uses borrowed data to replace owned data, usually by cloning. Read more

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T> ToOwned for Twhere + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/struct.PhysAddr.html b/ch5/os/mm/struct.PhysAddr.html index eaaeb9af..12d760c8 100644 --- a/ch5/os/mm/struct.PhysAddr.html +++ b/ch5/os/mm/struct.PhysAddr.html @@ -1,45 +1,28 @@ -PhysAddr in os::mm - Rust

    Struct os::mm::PhysAddr

    source · [−]
    pub struct PhysAddr(pub usize);
    Expand description

    physical address

    -

    Tuple Fields

    0: usize

    Implementations

    PhysAddr->PhysPageNum

    -

    PhysAddr->PhysPageNum

    -

    Get page offset

    -

    Check page aligned

    -

    Get mutable reference to PhysAddr value

    -

    Trait Implementations

    Returns a copy of the value. Read more

    -

    Performs copy-assignment from source. Read more

    -

    Formats the value using the given formatter. Read more

    -

    Converts to this type from the input type.

    -

    Converts to this type from the input type.

    -

    Converts to this type from the input type.

    -

    T: {PhysAddr, VirtAddr, PhysPageNum, VirtPageNum} +PhysAddr in os::mm - Rust

    Struct os::mm::PhysAddr

    source · 
    pub struct PhysAddr(pub usize);
    Expand description

    physical address

    +

    Tuple Fields§

    §0: usize

    Implementations§

    source§

    impl PhysAddr

    source

    pub fn floor(&self) -> PhysPageNum

    PhysAddr->PhysPageNum

    +
    source

    pub fn ceil(&self) -> PhysPageNum

    PhysAddr->PhysPageNum

    +
    source

    pub fn page_offset(&self) -> usize

    Get page offset

    +
    source

    pub fn aligned(&self) -> bool

    Check page aligned

    +
    source§

    impl PhysAddr

    source

    pub fn get_mut<T>(&self) -> &'static mut T

    Get mutable reference to PhysAddr value

    +

    Trait Implementations§

    source§

    impl Clone for PhysAddr

    source§

    fn clone(&self) -> PhysAddr

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for PhysAddr

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl From<PhysAddr> for PhysPageNum

    source§

    fn from(v: PhysAddr) -> Self

    Converts to this type from the input type.
    source§

    impl From<PhysAddr> for usize

    source§

    fn from(v: PhysAddr) -> Self

    Converts to this type from the input type.
    source§

    impl From<PhysPageNum> for PhysAddr

    source§

    fn from(v: PhysPageNum) -> Self

    Converts to this type from the input type.
    source§

    impl From<usize> for PhysAddr

    T: {PhysAddr, VirtAddr, PhysPageNum, VirtPageNum} T -> usize: T.0 usize -> T: usize.into()

    -

    Converts to this type from the input type.

    -

    This method returns an Ordering between self and other. Read more

    -

    Compares and returns the maximum of two values. Read more

    -

    Compares and returns the minimum of two values. Read more

    -

    Restrict a value to a certain interval. Read more

    -

    This method tests for self and other values to be equal, and is used -by ==. Read more

    -

    This method tests for !=.

    -

    This method returns an ordering between self and other values if one exists. Read more

    -

    This method tests less than (for self and other) and is used by the < operator. Read more

    -

    This method tests less than or equal to (for self and other) and is used by the <= -operator. Read more

    -

    This method tests greater than (for self and other) and is used by the > operator. Read more

    -

    This method tests greater than or equal to (for self and other) and is used by the >= -operator. Read more

    -

    Auto Trait Implementations

    Blanket Implementations

    Gets the TypeId of self. Read more

    -

    Immutably borrows from an owned value. Read more

    -

    Mutably borrows from an owned value. Read more

    -

    Returns the argument unchanged.

    -

    Calls U::from(self).

    +
    source§

    fn from(v: usize) -> Self

    Converts to this type from the input type.
    source§

    impl Ord for PhysAddr

    source§

    fn cmp(&self, other: &PhysAddr) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Selfwhere + Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Selfwhere + Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Selfwhere + Self: Sized + PartialOrd<Self>,

    Restrict a value to a certain interval. Read more
    source§

    impl PartialEq<PhysAddr> for PhysAddr

    source§

    fn eq(&self, other: &PhysAddr) -> bool

    This method tests for self and other values to be equal, and is used +by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always +sufficient, and should not be overridden without very good reason.
    source§

    impl PartialOrd<PhysAddr> for PhysAddr

    source§

    fn partial_cmp(&self, other: &PhysAddr) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    1.0.0 · source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    1.0.0 · source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= +operator. Read more
    1.0.0 · source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    1.0.0 · source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= +operator. Read more
    source§

    impl Copy for PhysAddr

    source§

    impl Eq for PhysAddr

    source§

    impl StructuralEq for PhysAddr

    source§

    impl StructuralPartialEq for PhysAddr

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The resulting type after obtaining ownership.

    -

    Creates owned data from borrowed data, usually by cloning. Read more

    -

    Uses borrowed data to replace owned data, usually by cloning. Read more

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T> ToOwned for Twhere + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/struct.PhysPageNum.html b/ch5/os/mm/struct.PhysPageNum.html index 38db20b0..7d758b9d 100644 --- a/ch5/os/mm/struct.PhysPageNum.html +++ b/ch5/os/mm/struct.PhysPageNum.html @@ -1,38 +1,21 @@ -PhysPageNum in os::mm - Rust

    Struct os::mm::PhysPageNum

    source · [−]
    pub struct PhysPageNum(pub usize);
    Expand description

    physical page number

    -

    Tuple Fields

    0: usize

    Implementations

    Get PageTableEntry on PhysPageNum

    -

    Trait Implementations

    Returns a copy of the value. Read more

    -

    Performs copy-assignment from source. Read more

    -

    Formats the value using the given formatter. Read more

    -

    Converts to this type from the input type.

    -

    Converts to this type from the input type.

    -

    Converts to this type from the input type.

    -

    Converts to this type from the input type.

    -

    This method returns an Ordering between self and other. Read more

    -

    Compares and returns the maximum of two values. Read more

    -

    Compares and returns the minimum of two values. Read more

    -

    Restrict a value to a certain interval. Read more

    -

    This method tests for self and other values to be equal, and is used -by ==. Read more

    -

    This method tests for !=.

    -

    This method returns an ordering between self and other values if one exists. Read more

    -

    This method tests less than (for self and other) and is used by the < operator. Read more

    -

    This method tests less than or equal to (for self and other) and is used by the <= -operator. Read more

    -

    This method tests greater than (for self and other) and is used by the > operator. Read more

    -

    This method tests greater than or equal to (for self and other) and is used by the >= -operator. Read more

    -

    Auto Trait Implementations

    Blanket Implementations

    Gets the TypeId of self. Read more

    -

    Immutably borrows from an owned value. Read more

    -

    Mutably borrows from an owned value. Read more

    -

    Returns the argument unchanged.

    -

    Calls U::from(self).

    +PhysPageNum in os::mm - Rust

    Struct os::mm::PhysPageNum

    source · 
    pub struct PhysPageNum(pub usize);
    Expand description

    physical page number

    +

    Tuple Fields§

    §0: usize

    Implementations§

    source§

    impl PhysPageNum

    source

    pub fn get_pte_array(&self) -> &'static mut [PageTableEntry]

    Get PageTableEntry on PhysPageNum

    +
    source

    pub fn get_bytes_array(&self) -> &'static mut [u8]

    source

    pub fn get_mut<T>(&self) -> &'static mut T

    Trait Implementations§

    source§

    impl Clone for PhysPageNum

    source§

    fn clone(&self) -> PhysPageNum

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for PhysPageNum

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl From<PhysAddr> for PhysPageNum

    source§

    fn from(v: PhysAddr) -> Self

    Converts to this type from the input type.
    source§

    impl From<PhysPageNum> for PhysAddr

    source§

    fn from(v: PhysPageNum) -> Self

    Converts to this type from the input type.
    source§

    impl From<PhysPageNum> for usize

    source§

    fn from(v: PhysPageNum) -> Self

    Converts to this type from the input type.
    source§

    impl From<usize> for PhysPageNum

    source§

    fn from(v: usize) -> Self

    Converts to this type from the input type.
    source§

    impl Ord for PhysPageNum

    source§

    fn cmp(&self, other: &PhysPageNum) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Selfwhere + Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Selfwhere + Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Selfwhere + Self: Sized + PartialOrd<Self>,

    Restrict a value to a certain interval. Read more
    source§

    impl PartialEq<PhysPageNum> for PhysPageNum

    source§

    fn eq(&self, other: &PhysPageNum) -> bool

    This method tests for self and other values to be equal, and is used +by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always +sufficient, and should not be overridden without very good reason.
    source§

    impl PartialOrd<PhysPageNum> for PhysPageNum

    source§

    fn partial_cmp(&self, other: &PhysPageNum) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    1.0.0 · source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    1.0.0 · source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= +operator. Read more
    1.0.0 · source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    1.0.0 · source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= +operator. Read more
    source§

    impl Copy for PhysPageNum

    source§

    impl Eq for PhysPageNum

    source§

    impl StructuralEq for PhysPageNum

    source§

    impl StructuralPartialEq for PhysPageNum

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The resulting type after obtaining ownership.

    -

    Creates owned data from borrowed data, usually by cloning. Read more

    -

    Uses borrowed data to replace owned data, usually by cloning. Read more

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T> ToOwned for Twhere + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/struct.VirtAddr.html b/ch5/os/mm/struct.VirtAddr.html index 6c26d123..01556bb3 100644 --- a/ch5/os/mm/struct.VirtAddr.html +++ b/ch5/os/mm/struct.VirtAddr.html @@ -1,42 +1,25 @@ -VirtAddr in os::mm - Rust

    Struct os::mm::VirtAddr

    source · [−]
    pub struct VirtAddr(pub usize);
    Expand description

    virtual address

    -

    Tuple Fields

    0: usize

    Implementations

    VirtAddr->VirtPageNum

    -

    VirtAddr->VirtPageNum

    -

    Get page offset

    -

    Check page aligned

    -

    Trait Implementations

    Returns a copy of the value. Read more

    -

    Performs copy-assignment from source. Read more

    -

    Debugging

    -

    Formats the value using the given formatter. Read more

    -

    Converts to this type from the input type.

    -

    Converts to this type from the input type.

    -

    Converts to this type from the input type.

    -

    Converts to this type from the input type.

    -

    This method returns an Ordering between self and other. Read more

    -

    Compares and returns the maximum of two values. Read more

    -

    Compares and returns the minimum of two values. Read more

    -

    Restrict a value to a certain interval. Read more

    -

    This method tests for self and other values to be equal, and is used -by ==. Read more

    -

    This method tests for !=.

    -

    This method returns an ordering between self and other values if one exists. Read more

    -

    This method tests less than (for self and other) and is used by the < operator. Read more

    -

    This method tests less than or equal to (for self and other) and is used by the <= -operator. Read more

    -

    This method tests greater than (for self and other) and is used by the > operator. Read more

    -

    This method tests greater than or equal to (for self and other) and is used by the >= -operator. Read more

    -

    Auto Trait Implementations

    Blanket Implementations

    Gets the TypeId of self. Read more

    -

    Immutably borrows from an owned value. Read more

    -

    Mutably borrows from an owned value. Read more

    -

    Returns the argument unchanged.

    -

    Calls U::from(self).

    +VirtAddr in os::mm - Rust

    Struct os::mm::VirtAddr

    source · 
    pub struct VirtAddr(pub usize);
    Expand description

    virtual address

    +

    Tuple Fields§

    §0: usize

    Implementations§

    source§

    impl VirtAddr

    source

    pub fn floor(&self) -> VirtPageNum

    VirtAddr->VirtPageNum

    +
    source

    pub fn ceil(&self) -> VirtPageNum

    VirtAddr->VirtPageNum

    +
    source

    pub fn page_offset(&self) -> usize

    Get page offset

    +
    source

    pub fn aligned(&self) -> bool

    Check page aligned

    +

    Trait Implementations§

    source§

    impl Clone for VirtAddr

    source§

    fn clone(&self) -> VirtAddr

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for VirtAddr

    Debugging

    +
    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl From<VirtAddr> for VirtPageNum

    source§

    fn from(v: VirtAddr) -> Self

    Converts to this type from the input type.
    source§

    impl From<VirtAddr> for usize

    source§

    fn from(v: VirtAddr) -> Self

    Converts to this type from the input type.
    source§

    impl From<VirtPageNum> for VirtAddr

    source§

    fn from(v: VirtPageNum) -> Self

    Converts to this type from the input type.
    source§

    impl From<usize> for VirtAddr

    source§

    fn from(v: usize) -> Self

    Converts to this type from the input type.
    source§

    impl Ord for VirtAddr

    source§

    fn cmp(&self, other: &VirtAddr) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Selfwhere + Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Selfwhere + Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Selfwhere + Self: Sized + PartialOrd<Self>,

    Restrict a value to a certain interval. Read more
    source§

    impl PartialEq<VirtAddr> for VirtAddr

    source§

    fn eq(&self, other: &VirtAddr) -> bool

    This method tests for self and other values to be equal, and is used +by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always +sufficient, and should not be overridden without very good reason.
    source§

    impl PartialOrd<VirtAddr> for VirtAddr

    source§

    fn partial_cmp(&self, other: &VirtAddr) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    1.0.0 · source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    1.0.0 · source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= +operator. Read more
    1.0.0 · source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    1.0.0 · source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= +operator. Read more
    source§

    impl Copy for VirtAddr

    source§

    impl Eq for VirtAddr

    source§

    impl StructuralEq for VirtAddr

    source§

    impl StructuralPartialEq for VirtAddr

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The resulting type after obtaining ownership.

    -

    Creates owned data from borrowed data, usually by cloning. Read more

    -

    Uses borrowed data to replace owned data, usually by cloning. Read more

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T> ToOwned for Twhere + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/mm/struct.VirtPageNum.html b/ch5/os/mm/struct.VirtPageNum.html index cf2ce74e..13c8fc3f 100644 --- a/ch5/os/mm/struct.VirtPageNum.html +++ b/ch5/os/mm/struct.VirtPageNum.html @@ -1,38 +1,21 @@ -VirtPageNum in os::mm - Rust

    Struct os::mm::VirtPageNum

    source · [−]
    pub struct VirtPageNum(pub usize);
    Expand description

    virtual page number

    -

    Tuple Fields

    0: usize

    Implementations

    Return VPN 3 level index

    -

    Trait Implementations

    Returns a copy of the value. Read more

    -

    Performs copy-assignment from source. Read more

    -

    Formats the value using the given formatter. Read more

    -

    Converts to this type from the input type.

    -

    Converts to this type from the input type.

    -

    Converts to this type from the input type.

    -

    Converts to this type from the input type.

    -

    This method returns an Ordering between self and other. Read more

    -

    Compares and returns the maximum of two values. Read more

    -

    Compares and returns the minimum of two values. Read more

    -

    Restrict a value to a certain interval. Read more

    -

    This method tests for self and other values to be equal, and is used -by ==. Read more

    -

    This method tests for !=.

    -

    This method returns an ordering between self and other values if one exists. Read more

    -

    This method tests less than (for self and other) and is used by the < operator. Read more

    -

    This method tests less than or equal to (for self and other) and is used by the <= -operator. Read more

    -

    This method tests greater than (for self and other) and is used by the > operator. Read more

    -

    This method tests greater than or equal to (for self and other) and is used by the >= -operator. Read more

    -

    Auto Trait Implementations

    Blanket Implementations

    Gets the TypeId of self. Read more

    -

    Immutably borrows from an owned value. Read more

    -

    Mutably borrows from an owned value. Read more

    -

    Returns the argument unchanged.

    -

    Calls U::from(self).

    +VirtPageNum in os::mm - Rust

    Struct os::mm::VirtPageNum

    source · 
    pub struct VirtPageNum(pub usize);
    Expand description

    virtual page number

    +

    Tuple Fields§

    §0: usize

    Implementations§

    source§

    impl VirtPageNum

    source

    pub fn indexes(&self) -> [usize; 3]

    Return VPN 3 level index

    +

    Trait Implementations§

    source§

    impl Clone for VirtPageNum

    source§

    fn clone(&self) -> VirtPageNum

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl Debug for VirtPageNum

    source§

    fn fmt(&self, f: &mut Formatter<'_>) -> Result

    Formats the value using the given formatter. Read more
    source§

    impl From<VirtAddr> for VirtPageNum

    source§

    fn from(v: VirtAddr) -> Self

    Converts to this type from the input type.
    source§

    impl From<VirtPageNum> for VirtAddr

    source§

    fn from(v: VirtPageNum) -> Self

    Converts to this type from the input type.
    source§

    impl From<VirtPageNum> for usize

    source§

    fn from(v: VirtPageNum) -> Self

    Converts to this type from the input type.
    source§

    impl From<usize> for VirtPageNum

    source§

    fn from(v: usize) -> Self

    Converts to this type from the input type.
    source§

    impl Ord for VirtPageNum

    source§

    fn cmp(&self, other: &VirtPageNum) -> Ordering

    This method returns an Ordering between self and other. Read more
    1.21.0 · source§

    fn max(self, other: Self) -> Selfwhere + Self: Sized,

    Compares and returns the maximum of two values. Read more
    1.21.0 · source§

    fn min(self, other: Self) -> Selfwhere + Self: Sized,

    Compares and returns the minimum of two values. Read more
    1.50.0 · source§

    fn clamp(self, min: Self, max: Self) -> Selfwhere + Self: Sized + PartialOrd<Self>,

    Restrict a value to a certain interval. Read more
    source§

    impl PartialEq<VirtPageNum> for VirtPageNum

    source§

    fn eq(&self, other: &VirtPageNum) -> bool

    This method tests for self and other values to be equal, and is used +by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always +sufficient, and should not be overridden without very good reason.
    source§

    impl PartialOrd<VirtPageNum> for VirtPageNum

    source§

    fn partial_cmp(&self, other: &VirtPageNum) -> Option<Ordering>

    This method returns an ordering between self and other values if one exists. Read more
    1.0.0 · source§

    fn lt(&self, other: &Rhs) -> bool

    This method tests less than (for self and other) and is used by the < operator. Read more
    1.0.0 · source§

    fn le(&self, other: &Rhs) -> bool

    This method tests less than or equal to (for self and other) and is used by the <= +operator. Read more
    1.0.0 · source§

    fn gt(&self, other: &Rhs) -> bool

    This method tests greater than (for self and other) and is used by the > operator. Read more
    1.0.0 · source§

    fn ge(&self, other: &Rhs) -> bool

    This method tests greater than or equal to (for self and other) and is used by the >= +operator. Read more
    source§

    impl StepByOne for VirtPageNum

    source§

    fn step(&mut self)

    source§

    impl Copy for VirtPageNum

    source§

    impl Eq for VirtPageNum

    source§

    impl StructuralEq for VirtPageNum

    source§

    impl StructuralPartialEq for VirtPageNum

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The resulting type after obtaining ownership.

    -

    Creates owned data from borrowed data, usually by cloning. Read more

    -

    Uses borrowed data to replace owned data, usually by cloning. Read more

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T> ToOwned for Twhere + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/sbi/fn.console_getchar.html b/ch5/os/sbi/fn.console_getchar.html index 59c93774..f480a50a 100644 --- a/ch5/os/sbi/fn.console_getchar.html +++ b/ch5/os/sbi/fn.console_getchar.html @@ -1,2 +1,2 @@ -console_getchar in os::sbi - Rust

    Function os::sbi::console_getchar

    source · [−]
    pub fn console_getchar() -> usize
    Expand description

    use sbi call to getchar from console (qemu uart handler)

    -
    \ No newline at end of file +console_getchar in os::sbi - Rust

    Function os::sbi::console_getchar

    source · 
    pub fn console_getchar() -> usize
    Expand description

    use sbi call to getchar from console (qemu uart handler)

    +
    \ No newline at end of file diff --git a/ch5/os/sbi/fn.console_putchar.html b/ch5/os/sbi/fn.console_putchar.html index 40cb32c3..e56c8eb0 100644 --- a/ch5/os/sbi/fn.console_putchar.html +++ b/ch5/os/sbi/fn.console_putchar.html @@ -1,2 +1,2 @@ -console_putchar in os::sbi - Rust

    Function os::sbi::console_putchar

    source · [−]
    pub fn console_putchar(c: usize)
    Expand description

    use sbi call to putchar in console (qemu uart handler)

    -
    \ No newline at end of file +console_putchar in os::sbi - Rust

    Function os::sbi::console_putchar

    source · 
    pub fn console_putchar(c: usize)
    Expand description

    use sbi call to putchar in console (qemu uart handler)

    +
    \ No newline at end of file diff --git a/ch5/os/sbi/fn.set_timer.html b/ch5/os/sbi/fn.set_timer.html index fbb76cb8..84acf5eb 100644 --- a/ch5/os/sbi/fn.set_timer.html +++ b/ch5/os/sbi/fn.set_timer.html @@ -1,2 +1,2 @@ -set_timer in os::sbi - Rust

    Function os::sbi::set_timer

    source · [−]
    pub fn set_timer(timer: usize)
    Expand description

    use sbi call to set timer

    -
    \ No newline at end of file +set_timer in os::sbi - Rust

    Function os::sbi::set_timer

    source · 
    pub fn set_timer(timer: usize)
    Expand description

    use sbi call to set timer

    +
    \ No newline at end of file diff --git a/ch5/os/sbi/fn.shutdown.html b/ch5/os/sbi/fn.shutdown.html index 6f6177b1..8c2a956b 100644 --- a/ch5/os/sbi/fn.shutdown.html +++ b/ch5/os/sbi/fn.shutdown.html @@ -1,2 +1,2 @@ -shutdown in os::sbi - Rust

    Function os::sbi::shutdown

    source · [−]
    pub fn shutdown(failure: bool) -> !
    Expand description

    use sbi call to shutdown the kernel

    -
    \ No newline at end of file +shutdown in os::sbi - Rust

    Function os::sbi::shutdown

    source · 
    pub fn shutdown(failure: bool) -> !
    Expand description

    use sbi call to shutdown the kernel

    +
    \ No newline at end of file diff --git a/ch5/os/sbi/index.html b/ch5/os/sbi/index.html index b9bba0c9..90c24f2b 100644 --- a/ch5/os/sbi/index.html +++ b/ch5/os/sbi/index.html @@ -1,6 +1,2 @@ -os::sbi - Rust

    Module os::sbi

    source · [−]
    Expand description

    SBI call wrappers

    -

    Functions

    console_getchar

    use sbi call to getchar from console (qemu uart handler)

    -
    console_putchar

    use sbi call to putchar in console (qemu uart handler)

    -
    set_timer

    use sbi call to set timer

    -
    shutdown

    use sbi call to shutdown the kernel

    -
    \ No newline at end of file +os::sbi - Rust

    Module os::sbi

    source ·
    Expand description

    SBI call wrappers

    +

    Functions

    \ No newline at end of file diff --git a/ch5/os/sbi/sidebar-items.js b/ch5/os/sbi/sidebar-items.js index 9c54a354..48cbb3c3 100644 --- a/ch5/os/sbi/sidebar-items.js +++ b/ch5/os/sbi/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"fn":[["console_getchar","use sbi call to getchar from console (qemu uart handler)"],["console_putchar","use sbi call to putchar in console (qemu uart handler)"],["set_timer","use sbi call to set timer"],["shutdown","use sbi call to shutdown the kernel"]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"fn":["console_getchar","console_putchar","set_timer","shutdown"]}; \ No newline at end of file diff --git a/ch5/os/sidebar-items.js b/ch5/os/sidebar-items.js index 82ae13f8..54d7ece7 100644 --- a/ch5/os/sidebar-items.js +++ b/ch5/os/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"fn":[["clear_bss","clear BSS segment"],["rust_main","the rust entry-point of os"]],"macro":[["print","print string macro"],["println","println string macro"]],"mod":[["board","Constants used in rCore for qemu"],["config","Constants used in rCore"],["console","SBI console driver, for text output"],["lang_items","The panic handler"],["loader","Loading user applications into memory"],["mm","Memory management implementation"],["sbi","SBI call wrappers"],["sync","Synchronization and interior mutability primitives"],["syscall","Implementation of syscalls"],["task","Task management implementation"],["timer","RISC-V timer-related functionality"],["trap","Trap handling functionality"]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"fn":["clear_bss","rust_main"],"macro":["print","println"],"mod":["board","config","console","lang_items","loader","mm","sbi","sync","syscall","task","timer","trap"]}; \ No newline at end of file diff --git a/ch5/os/sync/index.html b/ch5/os/sync/index.html index 4391bcb7..3c6c371d 100644 --- a/ch5/os/sync/index.html +++ b/ch5/os/sync/index.html @@ -1,5 +1,3 @@ -os::sync - Rust

    Module os::sync

    source · [−]
    Expand description

    Synchronization and interior mutability primitives

    -

    Modules

    up 🔒

    Uniprocessor interior mutability primitives

    -

    Structs

    UPSafeCell

    Wrap a static data structure inside it so that we are -able to access it without any unsafe.

    -
    \ No newline at end of file +os::sync - Rust

    Module os::sync

    source ·
    Expand description

    Synchronization and interior mutability primitives

    +

    Modules

    • up 🔒
      Uniprocessor interior mutability primitives

    Structs

    • UPSafeCell
      Wrap a static data structure inside it so that we are +able to access it without any unsafe.
    \ No newline at end of file diff --git a/ch5/os/sync/sidebar-items.js b/ch5/os/sync/sidebar-items.js index 751ae6d5..fdf90b45 100644 --- a/ch5/os/sync/sidebar-items.js +++ b/ch5/os/sync/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"mod":[["up","Uniprocessor interior mutability primitives"]],"struct":[["UPSafeCell","Wrap a static data structure inside it so that we are able to access it without any `unsafe`."]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"mod":["up"],"struct":["UPSafeCell"]}; \ No newline at end of file diff --git a/ch5/os/sync/struct.UPSafeCell.html b/ch5/os/sync/struct.UPSafeCell.html index 1ccb3c0b..7e6fe872 100644 --- a/ch5/os/sync/struct.UPSafeCell.html +++ b/ch5/os/sync/struct.UPSafeCell.html @@ -1,23 +1,25 @@ -UPSafeCell in os::sync - Rust

    Struct os::sync::UPSafeCell

    source · [−]
    pub struct UPSafeCell<T> {
+UPSafeCell in os::sync - Rust
    Struct os::sync::UPSafeCell
    source · 
    pub struct UPSafeCell<T> {
     inner: RefCell<T>,
-}
    Expand description
    Wrap a static data structure inside it so that we are
+}
    Expand description

    Wrap a static data structure inside it so that we are able to access it without any unsafe.

    We should only use it in uniprocessor.

    In order to get mutable reference of inner data, call exclusive_access.

    -

    Fields

    inner: RefCell<T>

    inner data

    -

    Implementations

    User is responsible to guarantee that inner struct is only used in +

    Fields§

    §inner: RefCell<T>

    inner data

    +

    Implementations§

    source§

    impl<T> UPSafeCell<T>

    source

    pub unsafe fn new(value: T) -> Self

    User is responsible to guarantee that inner struct is only used in uniprocessor.

    -

    Exclusive access inner data in UPSafeCell. Panic if the data has been borrowed.

    -

    Trait Implementations

    Auto Trait Implementations

    Blanket Implementations

    Gets the TypeId of self. Read more

    -

    Immutably borrows from an owned value. Read more

    -

    Mutably borrows from an owned value. Read more

    -

    Returns the argument unchanged.

    -

    Calls U::from(self).

    +
    source

    pub fn exclusive_access(&self) -> RefMut<'_, T>

    Exclusive access inner data in UPSafeCell. Panic if the data has been borrowed.

    +

    Trait Implementations§

    source§

    impl<T> Sync for UPSafeCell<T>

    Auto Trait Implementations§

    §

    impl<T> !RefUnwindSafe for UPSafeCell<T>

    §

    impl<T> Send for UPSafeCell<T>where + T: Send,

    §

    impl<T> Unpin for UPSafeCell<T>where + T: Unpin,

    §

    impl<T> UnwindSafe for UPSafeCell<T>where + T: UnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/sync/up/index.html b/ch5/os/sync/up/index.html index 45ca888e..e6457b0e 100644 --- a/ch5/os/sync/up/index.html +++ b/ch5/os/sync/up/index.html @@ -1,4 +1,3 @@ -os::sync::up - Rust

    Module os::sync::up

    source · [−]
    Expand description

    Uniprocessor interior mutability primitives

    -

    Structs

    UPSafeCell

    Wrap a static data structure inside it so that we are -able to access it without any unsafe.

    -
    \ No newline at end of file +os::sync::up - Rust

    Module os::sync::up

    source ·
    Expand description

    Uniprocessor interior mutability primitives

    +

    Structs

    • UPSafeCell
      Wrap a static data structure inside it so that we are +able to access it without any unsafe.
    \ No newline at end of file diff --git a/ch5/os/sync/up/sidebar-items.js b/ch5/os/sync/up/sidebar-items.js index 8f4cda09..f4e9455d 100644 --- a/ch5/os/sync/up/sidebar-items.js +++ b/ch5/os/sync/up/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"struct":[["UPSafeCell","Wrap a static data structure inside it so that we are able to access it without any `unsafe`."]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"struct":["UPSafeCell"]}; \ No newline at end of file diff --git a/ch5/os/sync/up/struct.UPSafeCell.html b/ch5/os/sync/up/struct.UPSafeCell.html index 67f15826..18e9ee32 100644 --- a/ch5/os/sync/up/struct.UPSafeCell.html +++ b/ch5/os/sync/up/struct.UPSafeCell.html @@ -1,23 +1,25 @@ -UPSafeCell in os::sync::up - Rust

    Struct os::sync::up::UPSafeCell

    source · [−]
    pub struct UPSafeCell<T> {
+UPSafeCell in os::sync::up - Rust
    Struct os::sync::up::UPSafeCell
    source · 
    pub struct UPSafeCell<T> {
     inner: RefCell<T>,
-}
    Expand description
    Wrap a static data structure inside it so that we are
+}
    Expand description

    Wrap a static data structure inside it so that we are able to access it without any unsafe.

    We should only use it in uniprocessor.

    In order to get mutable reference of inner data, call exclusive_access.

    -

    Fields

    inner: RefCell<T>

    inner data

    -

    Implementations

    User is responsible to guarantee that inner struct is only used in +

    Fields§

    §inner: RefCell<T>

    inner data

    +

    Implementations§

    source§

    impl<T> UPSafeCell<T>

    source

    pub unsafe fn new(value: T) -> Self

    User is responsible to guarantee that inner struct is only used in uniprocessor.

    -

    Exclusive access inner data in UPSafeCell. Panic if the data has been borrowed.

    -

    Trait Implementations

    Auto Trait Implementations

    Blanket Implementations

    Gets the TypeId of self. Read more

    -

    Immutably borrows from an owned value. Read more

    -

    Mutably borrows from an owned value. Read more

    -

    Returns the argument unchanged.

    -

    Calls U::from(self).

    +
    source

    pub fn exclusive_access(&self) -> RefMut<'_, T>

    Exclusive access inner data in UPSafeCell. Panic if the data has been borrowed.

    +

    Trait Implementations§

    source§

    impl<T> Sync for UPSafeCell<T>

    Auto Trait Implementations§

    §

    impl<T> !RefUnwindSafe for UPSafeCell<T>

    §

    impl<T> Send for UPSafeCell<T>where + T: Send,

    §

    impl<T> Unpin for UPSafeCell<T>where + T: Unpin,

    §

    impl<T> UnwindSafe for UPSafeCell<T>where + T: UnwindSafe,

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/syscall/constant.SYSCALL_EXEC.html b/ch5/os/syscall/constant.SYSCALL_EXEC.html index 408ccaaf..b9b060c5 100644 --- a/ch5/os/syscall/constant.SYSCALL_EXEC.html +++ b/ch5/os/syscall/constant.SYSCALL_EXEC.html @@ -1 +1 @@ -SYSCALL_EXEC in os::syscall - Rust

    Constant os::syscall::SYSCALL_EXEC

    source · [−]
    const SYSCALL_EXEC: usize = 221;
    \ No newline at end of file +SYSCALL_EXEC in os::syscall - Rust

    Constant os::syscall::SYSCALL_EXEC

    source · 
    const SYSCALL_EXEC: usize = 221;
    \ No newline at end of file diff --git a/ch5/os/syscall/constant.SYSCALL_EXIT.html b/ch5/os/syscall/constant.SYSCALL_EXIT.html index cb68704e..4865fd4a 100644 --- a/ch5/os/syscall/constant.SYSCALL_EXIT.html +++ b/ch5/os/syscall/constant.SYSCALL_EXIT.html @@ -1 +1 @@ -SYSCALL_EXIT in os::syscall - Rust

    Constant os::syscall::SYSCALL_EXIT

    source · [−]
    const SYSCALL_EXIT: usize = 93;
    \ No newline at end of file +SYSCALL_EXIT in os::syscall - Rust

    Constant os::syscall::SYSCALL_EXIT

    source · 
    const SYSCALL_EXIT: usize = 93;
    \ No newline at end of file diff --git a/ch5/os/syscall/constant.SYSCALL_FORK.html b/ch5/os/syscall/constant.SYSCALL_FORK.html index 689bbd85..6ef06bc7 100644 --- a/ch5/os/syscall/constant.SYSCALL_FORK.html +++ b/ch5/os/syscall/constant.SYSCALL_FORK.html @@ -1 +1 @@ -SYSCALL_FORK in os::syscall - Rust

    Constant os::syscall::SYSCALL_FORK

    source · [−]
    const SYSCALL_FORK: usize = 220;
    \ No newline at end of file +SYSCALL_FORK in os::syscall - Rust

    Constant os::syscall::SYSCALL_FORK

    source · 
    const SYSCALL_FORK: usize = 220;
    \ No newline at end of file diff --git a/ch5/os/syscall/constant.SYSCALL_GETPID.html b/ch5/os/syscall/constant.SYSCALL_GETPID.html index 58c41607..39cbb1d4 100644 --- a/ch5/os/syscall/constant.SYSCALL_GETPID.html +++ b/ch5/os/syscall/constant.SYSCALL_GETPID.html @@ -1 +1 @@ -SYSCALL_GETPID in os::syscall - Rust

    Constant os::syscall::SYSCALL_GETPID

    source · [−]
    const SYSCALL_GETPID: usize = 172;
    \ No newline at end of file +SYSCALL_GETPID in os::syscall - Rust

    Constant os::syscall::SYSCALL_GETPID

    source · 
    const SYSCALL_GETPID: usize = 172;
    \ No newline at end of file diff --git a/ch5/os/syscall/constant.SYSCALL_GET_TIME.html b/ch5/os/syscall/constant.SYSCALL_GET_TIME.html index 1f28ac14..b4068dff 100644 --- a/ch5/os/syscall/constant.SYSCALL_GET_TIME.html +++ b/ch5/os/syscall/constant.SYSCALL_GET_TIME.html @@ -1 +1 @@ -SYSCALL_GET_TIME in os::syscall - Rust

    Constant os::syscall::SYSCALL_GET_TIME

    source · [−]
    const SYSCALL_GET_TIME: usize = 169;
    \ No newline at end of file +SYSCALL_GET_TIME in os::syscall - Rust

    Constant os::syscall::SYSCALL_GET_TIME

    source · 
    const SYSCALL_GET_TIME: usize = 169;
    \ No newline at end of file diff --git a/ch5/os/syscall/constant.SYSCALL_READ.html b/ch5/os/syscall/constant.SYSCALL_READ.html index e480131b..dde4a148 100644 --- a/ch5/os/syscall/constant.SYSCALL_READ.html +++ b/ch5/os/syscall/constant.SYSCALL_READ.html @@ -1 +1 @@ -SYSCALL_READ in os::syscall - Rust

    Constant os::syscall::SYSCALL_READ

    source · [−]
    const SYSCALL_READ: usize = 63;
    \ No newline at end of file +SYSCALL_READ in os::syscall - Rust

    Constant os::syscall::SYSCALL_READ

    source · 
    const SYSCALL_READ: usize = 63;
    \ No newline at end of file diff --git a/ch5/os/syscall/constant.SYSCALL_WAITPID.html b/ch5/os/syscall/constant.SYSCALL_WAITPID.html index 90017fd4..661521fc 100644 --- a/ch5/os/syscall/constant.SYSCALL_WAITPID.html +++ b/ch5/os/syscall/constant.SYSCALL_WAITPID.html @@ -1 +1 @@ -SYSCALL_WAITPID in os::syscall - Rust

    Constant os::syscall::SYSCALL_WAITPID

    source · [−]
    const SYSCALL_WAITPID: usize = 260;
    \ No newline at end of file +SYSCALL_WAITPID in os::syscall - Rust

    Constant os::syscall::SYSCALL_WAITPID

    source · 
    const SYSCALL_WAITPID: usize = 260;
    \ No newline at end of file diff --git a/ch5/os/syscall/constant.SYSCALL_WRITE.html b/ch5/os/syscall/constant.SYSCALL_WRITE.html index d90f659f..bc8eff8a 100644 --- a/ch5/os/syscall/constant.SYSCALL_WRITE.html +++ b/ch5/os/syscall/constant.SYSCALL_WRITE.html @@ -1 +1 @@ -SYSCALL_WRITE in os::syscall - Rust

    Constant os::syscall::SYSCALL_WRITE

    source · [−]
    const SYSCALL_WRITE: usize = 64;
    \ No newline at end of file +SYSCALL_WRITE in os::syscall - Rust

    Constant os::syscall::SYSCALL_WRITE

    source · 
    const SYSCALL_WRITE: usize = 64;
    \ No newline at end of file diff --git a/ch5/os/syscall/constant.SYSCALL_YIELD.html b/ch5/os/syscall/constant.SYSCALL_YIELD.html index b4d92a07..8d3d5c0c 100644 --- a/ch5/os/syscall/constant.SYSCALL_YIELD.html +++ b/ch5/os/syscall/constant.SYSCALL_YIELD.html @@ -1 +1 @@ -SYSCALL_YIELD in os::syscall - Rust

    Constant os::syscall::SYSCALL_YIELD

    source · [−]
    const SYSCALL_YIELD: usize = 124;
    \ No newline at end of file +SYSCALL_YIELD in os::syscall - Rust

    Constant os::syscall::SYSCALL_YIELD

    source · 
    const SYSCALL_YIELD: usize = 124;
    \ No newline at end of file diff --git a/ch5/os/syscall/fn.syscall.html b/ch5/os/syscall/fn.syscall.html index 97700b56..518d4f18 100644 --- a/ch5/os/syscall/fn.syscall.html +++ b/ch5/os/syscall/fn.syscall.html @@ -1,2 +1,2 @@ -syscall in os::syscall - Rust

    Function os::syscall::syscall

    source · [−]
    pub fn syscall(syscall_id: usize, args: [usize; 3]) -> isize
    Expand description

    handle syscall exception with syscall_id and other arguments

    -
    \ No newline at end of file +syscall in os::syscall - Rust

    Function os::syscall::syscall

    source · 
    pub fn syscall(syscall_id: usize, args: [usize; 3]) -> isize
    Expand description

    handle syscall exception with syscall_id and other arguments

    +
    \ No newline at end of file diff --git a/ch5/os/syscall/fs/constant.FD_STDIN.html b/ch5/os/syscall/fs/constant.FD_STDIN.html index a0ccbe97..1c124785 100644 --- a/ch5/os/syscall/fs/constant.FD_STDIN.html +++ b/ch5/os/syscall/fs/constant.FD_STDIN.html @@ -1 +1 @@ -FD_STDIN in os::syscall::fs - Rust

    Constant os::syscall::fs::FD_STDIN

    source · [−]
    const FD_STDIN: usize = 0;
    \ No newline at end of file +FD_STDIN in os::syscall::fs - Rust

    Constant os::syscall::fs::FD_STDIN

    source · 
    const FD_STDIN: usize = 0;
    \ No newline at end of file diff --git a/ch5/os/syscall/fs/constant.FD_STDOUT.html b/ch5/os/syscall/fs/constant.FD_STDOUT.html index 79699600..5f3f80dd 100644 --- a/ch5/os/syscall/fs/constant.FD_STDOUT.html +++ b/ch5/os/syscall/fs/constant.FD_STDOUT.html @@ -1 +1 @@ -FD_STDOUT in os::syscall::fs - Rust

    Constant os::syscall::fs::FD_STDOUT

    source · [−]
    const FD_STDOUT: usize = 1;
    \ No newline at end of file +FD_STDOUT in os::syscall::fs - Rust

    Constant os::syscall::fs::FD_STDOUT

    source · 
    const FD_STDOUT: usize = 1;
    \ No newline at end of file diff --git a/ch5/os/syscall/fs/fn.sys_read.html b/ch5/os/syscall/fs/fn.sys_read.html index 4b85606f..6cac225e 100644 --- a/ch5/os/syscall/fs/fn.sys_read.html +++ b/ch5/os/syscall/fs/fn.sys_read.html @@ -1 +1 @@ -sys_read in os::syscall::fs - Rust

    Function os::syscall::fs::sys_read

    source · [−]
    pub fn sys_read(fd: usize, buf: *const u8, len: usize) -> isize
    \ No newline at end of file +sys_read in os::syscall::fs - Rust

    Function os::syscall::fs::sys_read

    source · 
    pub fn sys_read(fd: usize, buf: *const u8, len: usize) -> isize
    \ No newline at end of file diff --git a/ch5/os/syscall/fs/fn.sys_write.html b/ch5/os/syscall/fs/fn.sys_write.html index 22709f39..b3a67e60 100644 --- a/ch5/os/syscall/fs/fn.sys_write.html +++ b/ch5/os/syscall/fs/fn.sys_write.html @@ -1 +1 @@ -sys_write in os::syscall::fs - Rust

    Function os::syscall::fs::sys_write

    source · [−]
    pub fn sys_write(fd: usize, buf: *const u8, len: usize) -> isize
    \ No newline at end of file +sys_write in os::syscall::fs - Rust

    Function os::syscall::fs::sys_write

    source · 
    pub fn sys_write(fd: usize, buf: *const u8, len: usize) -> isize
    \ No newline at end of file diff --git a/ch5/os/syscall/fs/index.html b/ch5/os/syscall/fs/index.html index 6366c0f2..a15556ca 100644 --- a/ch5/os/syscall/fs/index.html +++ b/ch5/os/syscall/fs/index.html @@ -1,2 +1,2 @@ -os::syscall::fs - Rust

    Module os::syscall::fs

    source · [−]
    Expand description

    File and filesystem-related syscalls

    -

    Constants

    FD_STDIN 🔒
    FD_STDOUT 🔒

    Functions

    sys_read
    sys_write
    \ No newline at end of file +os::syscall::fs - Rust

    Module os::syscall::fs

    source ·
    Expand description

    File and filesystem-related syscalls

    +

    Constants

    Functions

    \ No newline at end of file diff --git a/ch5/os/syscall/fs/sidebar-items.js b/ch5/os/syscall/fs/sidebar-items.js index 8b470869..54b4bbb3 100644 --- a/ch5/os/syscall/fs/sidebar-items.js +++ b/ch5/os/syscall/fs/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"constant":[["FD_STDIN",""],["FD_STDOUT",""]],"fn":[["sys_read",""],["sys_write",""]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"constant":["FD_STDIN","FD_STDOUT"],"fn":["sys_read","sys_write"]}; \ No newline at end of file diff --git a/ch5/os/syscall/index.html b/ch5/os/syscall/index.html index 758ccc32..8cb869ad 100644 --- a/ch5/os/syscall/index.html +++ b/ch5/os/syscall/index.html @@ -1,12 +1,10 @@ -os::syscall - Rust

    Module os::syscall

    source · [−]
    Expand description

    Implementation of syscalls

    -

    The single entry point to all system calls, syscall(), is called +os::syscall - Rust

    Module os::syscall

    source ·
    Expand description

    Implementation of syscalls

    +

    The single entry point to all system calls, syscall(), is called whenever userspace wishes to perform a system call using the ecall instruction. In this case, the processor raises an ‘Environment call from U-mode’ exception, which is handled as one of the cases in -crate::trap::trap_handler.

    +crate::trap::trap_handler.

    For clarity, each single syscall is implemented as its own function, named sys_ then the name of the syscall. You can find functions like this in submodules, and you should also implement syscalls this way.

    -

    Modules

    fs 🔒

    File and filesystem-related syscalls

    -
    process 🔒

    Constants

    SYSCALL_EXEC 🔒
    SYSCALL_EXIT 🔒
    SYSCALL_FORK 🔒
    SYSCALL_GETPID 🔒
    SYSCALL_GET_TIME 🔒
    SYSCALL_READ 🔒
    SYSCALL_WAITPID 🔒
    SYSCALL_WRITE 🔒
    SYSCALL_YIELD 🔒

    Functions

    syscall

    handle syscall exception with syscall_id and other arguments

    -
    \ No newline at end of file +

    Modules

    • fs 🔒
      File and filesystem-related syscalls
    • process 🔒

    Constants

    Functions

    • syscall
      handle syscall exception with syscall_id and other arguments
    \ No newline at end of file diff --git a/ch5/os/syscall/process/fn.sys_exec.html b/ch5/os/syscall/process/fn.sys_exec.html index 5e563bef..efb92cff 100644 --- a/ch5/os/syscall/process/fn.sys_exec.html +++ b/ch5/os/syscall/process/fn.sys_exec.html @@ -1 +1 @@ -sys_exec in os::syscall::process - Rust

    Function os::syscall::process::sys_exec

    source · [−]
    pub fn sys_exec(path: *const u8) -> isize
    \ No newline at end of file +sys_exec in os::syscall::process - Rust

    Function os::syscall::process::sys_exec

    source · 
    pub fn sys_exec(path: *const u8) -> isize
    \ No newline at end of file diff --git a/ch5/os/syscall/process/fn.sys_exit.html b/ch5/os/syscall/process/fn.sys_exit.html index 60539219..6d684faf 100644 --- a/ch5/os/syscall/process/fn.sys_exit.html +++ b/ch5/os/syscall/process/fn.sys_exit.html @@ -1 +1 @@ -sys_exit in os::syscall::process - Rust

    Function os::syscall::process::sys_exit

    source · [−]
    pub fn sys_exit(exit_code: i32) -> !
    \ No newline at end of file +sys_exit in os::syscall::process - Rust

    Function os::syscall::process::sys_exit

    source · 
    pub fn sys_exit(exit_code: i32) -> !
    \ No newline at end of file diff --git a/ch5/os/syscall/process/fn.sys_fork.html b/ch5/os/syscall/process/fn.sys_fork.html index cc84139a..e56df4b8 100644 --- a/ch5/os/syscall/process/fn.sys_fork.html +++ b/ch5/os/syscall/process/fn.sys_fork.html @@ -1 +1 @@ -sys_fork in os::syscall::process - Rust

    Function os::syscall::process::sys_fork

    source · [−]
    pub fn sys_fork() -> isize
    \ No newline at end of file +sys_fork in os::syscall::process - Rust

    Function os::syscall::process::sys_fork

    source · 
    pub fn sys_fork() -> isize
    \ No newline at end of file diff --git a/ch5/os/syscall/process/fn.sys_get_time.html b/ch5/os/syscall/process/fn.sys_get_time.html index 6f3c273d..5d5f7a7e 100644 --- a/ch5/os/syscall/process/fn.sys_get_time.html +++ b/ch5/os/syscall/process/fn.sys_get_time.html @@ -1 +1 @@ -sys_get_time in os::syscall::process - Rust

    Function os::syscall::process::sys_get_time

    source · [−]
    pub fn sys_get_time() -> isize
    \ No newline at end of file +sys_get_time in os::syscall::process - Rust

    Function os::syscall::process::sys_get_time

    source · 
    pub fn sys_get_time() -> isize
    \ No newline at end of file diff --git a/ch5/os/syscall/process/fn.sys_getpid.html b/ch5/os/syscall/process/fn.sys_getpid.html index beb07c1d..e11ffb87 100644 --- a/ch5/os/syscall/process/fn.sys_getpid.html +++ b/ch5/os/syscall/process/fn.sys_getpid.html @@ -1 +1 @@ -sys_getpid in os::syscall::process - Rust

    Function os::syscall::process::sys_getpid

    source · [−]
    pub fn sys_getpid() -> isize
    \ No newline at end of file +sys_getpid in os::syscall::process - Rust

    Function os::syscall::process::sys_getpid

    source · 
    pub fn sys_getpid() -> isize
    \ No newline at end of file diff --git a/ch5/os/syscall/process/fn.sys_waitpid.html b/ch5/os/syscall/process/fn.sys_waitpid.html index 90a4599f..d3de8173 100644 --- a/ch5/os/syscall/process/fn.sys_waitpid.html +++ b/ch5/os/syscall/process/fn.sys_waitpid.html @@ -1,3 +1,3 @@ -sys_waitpid in os::syscall::process - Rust

    Function os::syscall::process::sys_waitpid

    source · [−]
    pub fn sys_waitpid(pid: isize, exit_code_ptr: *mut i32) -> isize
    Expand description

    If there is not a child process whose pid is same as given, return -1. +sys_waitpid in os::syscall::process - Rust

    Function os::syscall::process::sys_waitpid

    source · 
    pub fn sys_waitpid(pid: isize, exit_code_ptr: *mut i32) -> isize
    Expand description

    If there is not a child process whose pid is same as given, return -1. Else if there is a child process but it is still running, return -2.

    -
    \ No newline at end of file +
    \ No newline at end of file diff --git a/ch5/os/syscall/process/fn.sys_yield.html b/ch5/os/syscall/process/fn.sys_yield.html index 06c09463..9394cfd2 100644 --- a/ch5/os/syscall/process/fn.sys_yield.html +++ b/ch5/os/syscall/process/fn.sys_yield.html @@ -1 +1 @@ -sys_yield in os::syscall::process - Rust

    Function os::syscall::process::sys_yield

    source · [−]
    pub fn sys_yield() -> isize
    \ No newline at end of file +sys_yield in os::syscall::process - Rust

    Function os::syscall::process::sys_yield

    source · 
    pub fn sys_yield() -> isize
    \ No newline at end of file diff --git a/ch5/os/syscall/process/index.html b/ch5/os/syscall/process/index.html index 1f0d3fdc..0cfaaa38 100644 --- a/ch5/os/syscall/process/index.html +++ b/ch5/os/syscall/process/index.html @@ -1,3 +1,2 @@ -os::syscall::process - Rust

    Module os::syscall::process

    source · [−]

    Functions

    sys_exec
    sys_exit
    sys_fork
    sys_get_time
    sys_getpid
    sys_waitpid

    If there is not a child process whose pid is same as given, return -1. -Else if there is a child process but it is still running, return -2.

    -
    sys_yield
    \ No newline at end of file +os::syscall::process - Rust

    Module os::syscall::process

    source ·

    Functions

    \ No newline at end of file diff --git a/ch5/os/syscall/process/sidebar-items.js b/ch5/os/syscall/process/sidebar-items.js index 3f73be9e..c7cff172 100644 --- a/ch5/os/syscall/process/sidebar-items.js +++ b/ch5/os/syscall/process/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"fn":[["sys_exec",""],["sys_exit",""],["sys_fork",""],["sys_get_time",""],["sys_getpid",""],["sys_waitpid","If there is not a child process whose pid is same as given, return -1. Else if there is a child process but it is still running, return -2."],["sys_yield",""]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"fn":["sys_exec","sys_exit","sys_fork","sys_get_time","sys_getpid","sys_waitpid","sys_yield"]}; \ No newline at end of file diff --git a/ch5/os/syscall/sidebar-items.js b/ch5/os/syscall/sidebar-items.js index 57039b41..2803b8b0 100644 --- a/ch5/os/syscall/sidebar-items.js +++ b/ch5/os/syscall/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"constant":[["SYSCALL_EXEC",""],["SYSCALL_EXIT",""],["SYSCALL_FORK",""],["SYSCALL_GETPID",""],["SYSCALL_GET_TIME",""],["SYSCALL_READ",""],["SYSCALL_WAITPID",""],["SYSCALL_WRITE",""],["SYSCALL_YIELD",""]],"fn":[["syscall","handle syscall exception with `syscall_id` and other arguments"]],"mod":[["fs","File and filesystem-related syscalls"],["process",""]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"constant":["SYSCALL_EXEC","SYSCALL_EXIT","SYSCALL_FORK","SYSCALL_GETPID","SYSCALL_GET_TIME","SYSCALL_READ","SYSCALL_WAITPID","SYSCALL_WRITE","SYSCALL_YIELD"],"fn":["syscall"],"mod":["fs","process"]}; \ No newline at end of file diff --git a/ch5/os/task/constant.IDLE_PID.html b/ch5/os/task/constant.IDLE_PID.html index 15ad6d76..421c316c 100644 --- a/ch5/os/task/constant.IDLE_PID.html +++ b/ch5/os/task/constant.IDLE_PID.html @@ -1,2 +1,2 @@ -IDLE_PID in os::task - Rust

    Constant os::task::IDLE_PID

    source · [−]
    pub const IDLE_PID: usize = 0;
    Expand description

    pid of usertests app in make run TEST=1

    -
    \ No newline at end of file +IDLE_PID in os::task - Rust

    Constant os::task::IDLE_PID

    source · 
    pub const IDLE_PID: usize = 0;
    Expand description

    pid of usertests app in make run TEST=1

    +
    \ No newline at end of file diff --git a/ch5/os/task/context/index.html b/ch5/os/task/context/index.html index 9240d663..0fed0d17 100644 --- a/ch5/os/task/context/index.html +++ b/ch5/os/task/context/index.html @@ -1,3 +1,2 @@ -os::task::context - Rust

    Module os::task::context

    source · [−]
    Expand description

    Implementation of TaskContext

    -

    Structs

    TaskContext

    task context structure containing some registers

    -
    \ No newline at end of file +os::task::context - Rust

    Module os::task::context

    source ·
    Expand description

    Implementation of TaskContext

    +

    Structs

    • TaskContext
      task context structure containing some registers
    \ No newline at end of file diff --git a/ch5/os/task/context/sidebar-items.js b/ch5/os/task/context/sidebar-items.js index a33372da..f64436cc 100644 --- a/ch5/os/task/context/sidebar-items.js +++ b/ch5/os/task/context/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"struct":[["TaskContext","task context structure containing some registers"]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"struct":["TaskContext"]}; \ No newline at end of file diff --git a/ch5/os/task/context/struct.TaskContext.html b/ch5/os/task/context/struct.TaskContext.html index 7cfcb451..49ceaaf9 100644 --- a/ch5/os/task/context/struct.TaskContext.html +++ b/ch5/os/task/context/struct.TaskContext.html @@ -1,22 +1,21 @@ -TaskContext in os::task::context - Rust

    Struct os::task::context::TaskContext

    source · [−]
    #[repr(C)]
    pub struct TaskContext {
+TaskContext in os::task::context - Rust
    Struct os::task::context::TaskContext
    source · 
    #[repr(C)]
    pub struct TaskContext {
     ra: usize,
     sp: usize,
-    s: [usize; 12],
-}
    Expand description
    task context structure containing some registers
    
-
    Fields
    ra: usize
    return address ( e.g. __restore ) of __switch ASM function
    
-
    sp: usize
    kernel stack pointer of app
    
-
    s: [usize; 12]
    s0-11 register, callee saved
    
-
    Implementations
    init task context
    
-
    set Task Context{__restore ASM funciton: trap_return, sp: kstack_ptr, s: s_0..12}
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+    s: [usize; 12],
+}
    Expand description

    task context structure containing some registers

    +

    Fields§

    §ra: usize

    return address ( e.g. __restore ) of __switch ASM function

    +
    §sp: usize

    kernel stack pointer of app

    +
    §s: [usize; 12]

    s0-11 register, callee saved

    +

    Implementations§

    source§

    impl TaskContext

    source

    pub fn zero_init() -> Self

    init task context

    +
    source

    pub fn goto_trap_return(kstack_ptr: usize) -> Self

    set Task Context{__restore ASM funciton: trap_return, sp: kstack_ptr, s: s_0..12}

    +

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/task/fn.add_initproc.html b/ch5/os/task/fn.add_initproc.html index 24626332..06a045d5 100644 --- a/ch5/os/task/fn.add_initproc.html +++ b/ch5/os/task/fn.add_initproc.html @@ -1,2 +1,2 @@ -add_initproc in os::task - Rust

    Function os::task::add_initproc

    source · [−]
    pub fn add_initproc()
    Expand description

    Add init process to the manager

    -
    \ No newline at end of file +add_initproc in os::task - Rust

    Function os::task::add_initproc

    source · 
    pub fn add_initproc()
    Expand description

    Add init process to the manager

    +
    \ No newline at end of file diff --git a/ch5/os/task/fn.add_task.html b/ch5/os/task/fn.add_task.html index 518f842e..c88b999b 100644 --- a/ch5/os/task/fn.add_task.html +++ b/ch5/os/task/fn.add_task.html @@ -1,2 +1,2 @@ -add_task in os::task - Rust

    Function os::task::add_task

    source · [−]
    pub fn add_task(task: Arc<TaskControlBlock>)
    Expand description

    Interface offered to add task

    -
    \ No newline at end of file +add_task in os::task - Rust

    Function os::task::add_task

    source · 
    pub fn add_task(task: Arc<TaskControlBlock>)
    Expand description

    Interface offered to add task

    +
    \ No newline at end of file diff --git a/ch5/os/task/fn.current_task.html b/ch5/os/task/fn.current_task.html index e18ee964..8306af47 100644 --- a/ch5/os/task/fn.current_task.html +++ b/ch5/os/task/fn.current_task.html @@ -1,2 +1,2 @@ -current_task in os::task - Rust

    Function os::task::current_task

    source · [−]
    pub fn current_task() -> Option<Arc<TaskControlBlock>>
    Expand description

    Get running task

    -
    \ No newline at end of file +current_task in os::task - Rust

    Function os::task::current_task

    source · 
    pub fn current_task() -> Option<Arc<TaskControlBlock>>
    Expand description

    Get running task

    +
    \ No newline at end of file diff --git a/ch5/os/task/fn.current_trap_cx.html b/ch5/os/task/fn.current_trap_cx.html index 031ba95f..293cd33c 100644 --- a/ch5/os/task/fn.current_trap_cx.html +++ b/ch5/os/task/fn.current_trap_cx.html @@ -1,2 +1,2 @@ -current_trap_cx in os::task - Rust

    Function os::task::current_trap_cx

    source · [−]
    pub fn current_trap_cx() -> &'static mut TrapContext
    Expand description

    Get the mutable reference to trap context of current task

    -
    \ No newline at end of file +current_trap_cx in os::task - Rust

    Function os::task::current_trap_cx

    source · 
    pub fn current_trap_cx() -> &'static mut TrapContext
    Expand description

    Get the mutable reference to trap context of current task

    +
    \ No newline at end of file diff --git a/ch5/os/task/fn.current_user_token.html b/ch5/os/task/fn.current_user_token.html index 6f11a2a3..66e6c27a 100644 --- a/ch5/os/task/fn.current_user_token.html +++ b/ch5/os/task/fn.current_user_token.html @@ -1,2 +1,2 @@ -current_user_token in os::task - Rust

    Function os::task::current_user_token

    source · [−]
    pub fn current_user_token() -> usize
    Expand description

    Get token of the address space of current task

    -
    \ No newline at end of file +current_user_token in os::task - Rust

    Function os::task::current_user_token

    source · 
    pub fn current_user_token() -> usize
    Expand description

    Get token of the address space of current task

    +
    \ No newline at end of file diff --git a/ch5/os/task/fn.exit_current_and_run_next.html b/ch5/os/task/fn.exit_current_and_run_next.html index a39c486f..7d16b005 100644 --- a/ch5/os/task/fn.exit_current_and_run_next.html +++ b/ch5/os/task/fn.exit_current_and_run_next.html @@ -1,2 +1,2 @@ -exit_current_and_run_next in os::task - Rust

    Function os::task::exit_current_and_run_next

    source · [−]
    pub fn exit_current_and_run_next(exit_code: i32)
    Expand description

    Exit the current ‘Running’ task and run the next task in task list.

    -
    \ No newline at end of file +exit_current_and_run_next in os::task - Rust

    Function os::task::exit_current_and_run_next

    source · 
    pub fn exit_current_and_run_next(exit_code: i32)
    Expand description

    Exit the current ‘Running’ task and run the next task in task list.

    +
    \ No newline at end of file diff --git a/ch5/os/task/fn.fetch_task.html b/ch5/os/task/fn.fetch_task.html index 1bd0282c..2d27aa7c 100644 --- a/ch5/os/task/fn.fetch_task.html +++ b/ch5/os/task/fn.fetch_task.html @@ -1,2 +1,2 @@ -fetch_task in os::task - Rust

    Function os::task::fetch_task

    source · [−]
    pub fn fetch_task() -> Option<Arc<TaskControlBlock>>
    Expand description

    Interface offered to pop the first task

    -
    \ No newline at end of file +fetch_task in os::task - Rust

    Function os::task::fetch_task

    source · 
    pub fn fetch_task() -> Option<Arc<TaskControlBlock>>
    Expand description

    Interface offered to pop the first task

    +
    \ No newline at end of file diff --git a/ch5/os/task/fn.pid_alloc.html b/ch5/os/task/fn.pid_alloc.html index 65d909c0..4cf1a968 100644 --- a/ch5/os/task/fn.pid_alloc.html +++ b/ch5/os/task/fn.pid_alloc.html @@ -1,2 +1,2 @@ -pid_alloc in os::task - Rust

    Function os::task::pid_alloc

    source · [−]
    pub fn pid_alloc() -> PidHandle
    Expand description

    Allocate a pid from PID_ALLOCATOR

    -
    \ No newline at end of file +pid_alloc in os::task - Rust

    Function os::task::pid_alloc

    source · 
    pub fn pid_alloc() -> PidHandle
    Expand description

    Allocate a pid from PID_ALLOCATOR

    +
    \ No newline at end of file diff --git a/ch5/os/task/fn.run_tasks.html b/ch5/os/task/fn.run_tasks.html index c6e96d8c..fde15911 100644 --- a/ch5/os/task/fn.run_tasks.html +++ b/ch5/os/task/fn.run_tasks.html @@ -1,3 +1,3 @@ -run_tasks in os::task - Rust

    Function os::task::run_tasks

    source · [−]
    pub fn run_tasks()
    Expand description

    The main part of process execution and scheduling +run_tasks in os::task - Rust

    Function os::task::run_tasks

    source · 
    pub fn run_tasks()
    Expand description

    The main part of process execution and scheduling Loop fetch_task to get the process that needs to run, and switch the process through __switch

    -
    \ No newline at end of file +
    \ No newline at end of file diff --git a/ch5/os/task/fn.schedule.html b/ch5/os/task/fn.schedule.html index 25b4a0f6..142ea291 100644 --- a/ch5/os/task/fn.schedule.html +++ b/ch5/os/task/fn.schedule.html @@ -1,2 +1,2 @@ -schedule in os::task - Rust

    Function os::task::schedule

    source · [−]
    pub fn schedule(switched_task_cx_ptr: *mut TaskContext)
    Expand description

    Return to idle control flow for new scheduling

    -
    \ No newline at end of file +schedule in os::task - Rust

    Function os::task::schedule

    source · 
    pub fn schedule(switched_task_cx_ptr: *mut TaskContext)
    Expand description

    Return to idle control flow for new scheduling

    +
    \ No newline at end of file diff --git a/ch5/os/task/fn.suspend_current_and_run_next.html b/ch5/os/task/fn.suspend_current_and_run_next.html index cfc0db65..eba067ba 100644 --- a/ch5/os/task/fn.suspend_current_and_run_next.html +++ b/ch5/os/task/fn.suspend_current_and_run_next.html @@ -1,2 +1,2 @@ -suspend_current_and_run_next in os::task - Rust

    Function os::task::suspend_current_and_run_next

    source · [−]
    pub fn suspend_current_and_run_next()
    Expand description

    Suspend the current ‘Running’ task and run the next task in task list.

    -
    \ No newline at end of file +suspend_current_and_run_next in os::task - Rust

    Function os::task::suspend_current_and_run_next

    source · 
    pub fn suspend_current_and_run_next()
    Expand description

    Suspend the current ‘Running’ task and run the next task in task list.

    +
    \ No newline at end of file diff --git a/ch5/os/task/fn.take_current_task.html b/ch5/os/task/fn.take_current_task.html index c3317f4d..c8466f8a 100644 --- a/ch5/os/task/fn.take_current_task.html +++ b/ch5/os/task/fn.take_current_task.html @@ -1,2 +1,2 @@ -take_current_task in os::task - Rust

    Function os::task::take_current_task

    source · [−]
    pub fn take_current_task() -> Option<Arc<TaskControlBlock>>
    Expand description

    Take the current task,leaving a None in its place

    -
    \ No newline at end of file +take_current_task in os::task - Rust

    Function os::task::take_current_task

    source · 
    pub fn take_current_task() -> Option<Arc<TaskControlBlock>>
    Expand description

    Take the current task,leaving a None in its place

    +
    \ No newline at end of file diff --git a/ch5/os/task/index.html b/ch5/os/task/index.html index d0fc8917..00b8014a 100644 --- a/ch5/os/task/index.html +++ b/ch5/os/task/index.html @@ -1,39 +1,13 @@ -os::task - Rust

    Module os::task

    source · [−]
    Expand description

    Task management implementation

    +os::task - Rust

    Module os::task

    source ·
    Expand description

    Task management implementation

    Everything about task management, like starting and switching tasks is implemented here.

    -

    A single global instance of TaskManager called TASK_MANAGER controls +

    A single global instance of TaskManager called TASK_MANAGER controls all the tasks in the whole operating system.

    -

    A single global instance of Processor called PROCESSOR monitors running +

    A single global instance of Processor called PROCESSOR monitors running task(s) for each core.

    -

    A single global instance of PidAllocator called PID_ALLOCATOR allocates +

    A single global instance of PidAllocator called PID_ALLOCATOR allocates pid for user apps.

    Be careful when you see __switch ASM function in switch.S. Control flow around this function might not be what you expect.

    -

    Modules

    context 🔒

    Implementation of TaskContext

    -
    manager 🔒

    Implementation of TaskManager

    -
    pid 🔒

    Implementation of PidAllocator

    -
    processor 🔒

    Implementation of Processor and Intersection of control flow

    -
    switch 🔒

    Wrap switch.S as a function

    -
    task 🔒

    Implementation of TaskControlBlock

    -

    Structs

    INITPROC

    Globle process that init user shell

    -
    KernelStack

    Kernelstack for app

    -
    PidAllocator

    Pid Allocator struct

    -
    PidHandle

    Bind pid lifetime to PidHandle

    -
    Processor

    Processor management structure

    -
    TaskContext

    task context structure containing some registers

    -
    TaskManager

    A array of TaskControlBlock that is thread-safe

    -

    Constants

    IDLE_PID

    pid of usertests app in make run TEST=1

    -

    Functions

    add_initproc

    Add init process to the manager

    -
    add_task

    Interface offered to add task

    -
    current_task

    Get running task

    -
    current_trap_cx

    Get the mutable reference to trap context of current task

    -
    current_user_token

    Get token of the address space of current task

    -
    exit_current_and_run_next

    Exit the current ‘Running’ task and run the next task in task list.

    -
    fetch_task

    Interface offered to pop the first task

    -
    pid_alloc

    Allocate a pid from PID_ALLOCATOR

    -
    run_tasks

    The main part of process execution and scheduling -Loop fetch_task to get the process that needs to run, and switch the process through __switch

    -
    schedule

    Return to idle control flow for new scheduling

    -
    suspend_current_and_run_next

    Suspend the current ‘Running’ task and run the next task in task list.

    -
    take_current_task

    Take the current task,leaving a None in its place

    -
    \ No newline at end of file +

    Modules

    Structs

    Constants

    • IDLE_PID
      pid of usertests app in make run TEST=1

    Functions

    \ No newline at end of file diff --git a/ch5/os/task/manager/fn.add_task.html b/ch5/os/task/manager/fn.add_task.html index 9ca54c1c..f101e4fc 100644 --- a/ch5/os/task/manager/fn.add_task.html +++ b/ch5/os/task/manager/fn.add_task.html @@ -1,2 +1,2 @@ -add_task in os::task::manager - Rust

    Function os::task::manager::add_task

    source · [−]
    pub fn add_task(task: Arc<TaskControlBlock>)
    Expand description

    Interface offered to add task

    -
    \ No newline at end of file +add_task in os::task::manager - Rust

    Function os::task::manager::add_task

    source · 
    pub fn add_task(task: Arc<TaskControlBlock>)
    Expand description

    Interface offered to add task

    +
    \ No newline at end of file diff --git a/ch5/os/task/manager/fn.fetch_task.html b/ch5/os/task/manager/fn.fetch_task.html index 29c1cecc..080b520b 100644 --- a/ch5/os/task/manager/fn.fetch_task.html +++ b/ch5/os/task/manager/fn.fetch_task.html @@ -1,2 +1,2 @@ -fetch_task in os::task::manager - Rust

    Function os::task::manager::fetch_task

    source · [−]
    pub fn fetch_task() -> Option<Arc<TaskControlBlock>>
    Expand description

    Interface offered to pop the first task

    -
    \ No newline at end of file +fetch_task in os::task::manager - Rust

    Function os::task::manager::fetch_task

    source · 
    pub fn fetch_task() -> Option<Arc<TaskControlBlock>>
    Expand description

    Interface offered to pop the first task

    +
    \ No newline at end of file diff --git a/ch5/os/task/manager/index.html b/ch5/os/task/manager/index.html index 7d5b6c90..e3cf325f 100644 --- a/ch5/os/task/manager/index.html +++ b/ch5/os/task/manager/index.html @@ -1,5 +1,2 @@ -os::task::manager - Rust

    Module os::task::manager

    source · [−]
    Expand description

    Implementation of TaskManager

    -

    Structs

    TASK_MANAGER
    TaskManager

    A array of TaskControlBlock that is thread-safe

    -

    Functions

    add_task

    Interface offered to add task

    -
    fetch_task

    Interface offered to pop the first task

    -
    \ No newline at end of file +os::task::manager - Rust

    Module os::task::manager

    source ·
    Expand description

    Implementation of TaskManager

    +

    Structs

    Functions

    \ No newline at end of file diff --git a/ch5/os/task/manager/sidebar-items.js b/ch5/os/task/manager/sidebar-items.js index 2d0e3134..4f27ad34 100644 --- a/ch5/os/task/manager/sidebar-items.js +++ b/ch5/os/task/manager/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"fn":[["add_task","Interface offered to add task"],["fetch_task","Interface offered to pop the first task"]],"struct":[["TASK_MANAGER",""],["TaskManager","A array of `TaskControlBlock` that is thread-safe"]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"fn":["add_task","fetch_task"],"struct":["TASK_MANAGER","TaskManager"]}; \ No newline at end of file diff --git a/ch5/os/task/manager/struct.TASK_MANAGER.html b/ch5/os/task/manager/struct.TASK_MANAGER.html index f07eea1f..da7686f4 100644 --- a/ch5/os/task/manager/struct.TASK_MANAGER.html +++ b/ch5/os/task/manager/struct.TASK_MANAGER.html @@ -1,17 +1,14 @@ -TASK_MANAGER in os::task::manager - Rust

    Struct os::task::manager::TASK_MANAGER

    source · [−]
    pub struct TASK_MANAGER {
+TASK_MANAGER in os::task::manager - Rust
    Struct os::task::manager::TASK_MANAGER
    source · 
    pub struct TASK_MANAGER {
     __private_field: (),
-}
    Fields
    __private_field: ()
    Methods from Deref<Target = UPSafeCell<TaskManager>>
    Exclusive access inner data in UPSafeCell. Panic if the data has been borrowed.
    
-
    Trait Implementations
    The resulting type after dereferencing.
    
-
    Dereferences the value.
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}

    Fields§

    §__private_field: ()

    Methods from Deref<Target = UPSafeCell<TaskManager>>§

    source

    pub fn exclusive_access(&self) -> RefMut<'_, T>

    Exclusive access inner data in UPSafeCell. Panic if the data has been borrowed.

    +

    Trait Implementations§

    source§

    impl Deref for TASK_MANAGER

    §

    type Target = UPSafeCell<TaskManager>

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &UPSafeCell<TaskManager>

    Dereferences the value.
    source§

    impl LazyStatic for TASK_MANAGER

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/task/manager/struct.TaskManager.html b/ch5/os/task/manager/struct.TaskManager.html index 014a1596..e8518360 100644 --- a/ch5/os/task/manager/struct.TaskManager.html +++ b/ch5/os/task/manager/struct.TaskManager.html @@ -1,19 +1,18 @@ -TaskManager in os::task::manager - Rust

    Struct os::task::manager::TaskManager

    source · [−]
    pub struct TaskManager {
+TaskManager in os::task::manager - Rust
    Struct os::task::manager::TaskManager
    source · 
    pub struct TaskManager {
     ready_queue: VecDeque<Arc<TaskControlBlock>>,
-}
    Expand description
    A array of TaskControlBlock that is thread-safe
    
-
    Fields
    ready_queue: VecDeque<Arc<TaskControlBlock>>
    Implementations
    A simple FIFO scheduler.
    
-
    Creat an empty TaskManager
    
-
    Add a task to TaskManager
    
-
    Remove the first task and return it,or None if TaskManager is empty
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}
    Expand description

    A array of TaskControlBlock that is thread-safe

    +

    Fields§

    §ready_queue: VecDeque<Arc<TaskControlBlock>>

    Implementations§

    source§

    impl TaskManager

    A simple FIFO scheduler.

    +
    source

    pub fn new() -> Self

    Creat an empty TaskManager

    +
    source

    pub fn add(&mut self, task: Arc<TaskControlBlock>)

    Add a task to TaskManager

    +
    source

    pub fn fetch(&mut self) -> Option<Arc<TaskControlBlock>>

    Remove the first task and return it,or None if TaskManager is empty

    +

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/task/pid/fn.kernel_stack_position.html b/ch5/os/task/pid/fn.kernel_stack_position.html index 0791a2ae..05f462a2 100644 --- a/ch5/os/task/pid/fn.kernel_stack_position.html +++ b/ch5/os/task/pid/fn.kernel_stack_position.html @@ -1,2 +1,2 @@ -kernel_stack_position in os::task::pid - Rust

    Function os::task::pid::kernel_stack_position

    source · [−]
    pub fn kernel_stack_position(app_id: usize) -> (usize, usize)
    Expand description

    Return (bottom, top) of a kernel stack in kernel space.

    -
    \ No newline at end of file +kernel_stack_position in os::task::pid - Rust

    Function os::task::pid::kernel_stack_position

    source · 
    pub fn kernel_stack_position(app_id: usize) -> (usize, usize)
    Expand description

    Return (bottom, top) of a kernel stack in kernel space.

    +
    \ No newline at end of file diff --git a/ch5/os/task/pid/fn.pid_alloc.html b/ch5/os/task/pid/fn.pid_alloc.html index fa88b162..8599352c 100644 --- a/ch5/os/task/pid/fn.pid_alloc.html +++ b/ch5/os/task/pid/fn.pid_alloc.html @@ -1,2 +1,2 @@ -pid_alloc in os::task::pid - Rust

    Function os::task::pid::pid_alloc

    source · [−]
    pub fn pid_alloc() -> PidHandle
    Expand description

    Allocate a pid from PID_ALLOCATOR

    -
    \ No newline at end of file +pid_alloc in os::task::pid - Rust

    Function os::task::pid::pid_alloc

    source · 
    pub fn pid_alloc() -> PidHandle
    Expand description

    Allocate a pid from PID_ALLOCATOR

    +
    \ No newline at end of file diff --git a/ch5/os/task/pid/index.html b/ch5/os/task/pid/index.html index 5a2b65fd..80be16d4 100644 --- a/ch5/os/task/pid/index.html +++ b/ch5/os/task/pid/index.html @@ -1,7 +1,2 @@ -os::task::pid - Rust

    Module os::task::pid

    source · [−]
    Expand description

    Implementation of PidAllocator

    -

    Structs

    KernelStack

    Kernelstack for app

    -
    PID_ALLOCATOR
    PidAllocator

    Pid Allocator struct

    -
    PidHandle

    Bind pid lifetime to PidHandle

    -

    Functions

    kernel_stack_position

    Return (bottom, top) of a kernel stack in kernel space.

    -
    pid_alloc

    Allocate a pid from PID_ALLOCATOR

    -
    \ No newline at end of file +os::task::pid - Rust

    Module os::task::pid

    source ·
    Expand description

    Implementation of PidAllocator

    +

    Structs

    Functions

    \ No newline at end of file diff --git a/ch5/os/task/pid/sidebar-items.js b/ch5/os/task/pid/sidebar-items.js index 836f33e0..8392d298 100644 --- a/ch5/os/task/pid/sidebar-items.js +++ b/ch5/os/task/pid/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"fn":[["kernel_stack_position","Return (bottom, top) of a kernel stack in kernel space."],["pid_alloc","Allocate a pid from PID_ALLOCATOR"]],"struct":[["KernelStack","Kernelstack for app"],["PID_ALLOCATOR",""],["PidAllocator","Pid Allocator struct"],["PidHandle","Bind pid lifetime to `PidHandle`"]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"fn":["kernel_stack_position","pid_alloc"],"struct":["KernelStack","PID_ALLOCATOR","PidAllocator","PidHandle"]}; \ No newline at end of file diff --git a/ch5/os/task/pid/struct.KernelStack.html b/ch5/os/task/pid/struct.KernelStack.html index a1bb31ae..afa40ac9 100644 --- a/ch5/os/task/pid/struct.KernelStack.html +++ b/ch5/os/task/pid/struct.KernelStack.html @@ -1,19 +1,18 @@ -KernelStack in os::task::pid - Rust

    Struct os::task::pid::KernelStack

    source · [−]
    pub struct KernelStack {
+KernelStack in os::task::pid - Rust
    Struct os::task::pid::KernelStack
    source · 
    pub struct KernelStack {
     pid: usize,
-}
    Expand description
    Kernelstack for app
    
-
    Fields
    pid: usize
    Implementations
    Create a kernelstack from pid
    
-
    Push a value on top of kernelstack
    
-
    Get the value on the top of kernelstack
    
-
    Trait Implementations
    Executes the destructor for this type. Read more
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}
    Expand description

    Kernelstack for app

    +

    Fields§

    §pid: usize

    Implementations§

    source§

    impl KernelStack

    source

    pub fn new(pid_handle: &PidHandle) -> Self

    Create a kernelstack from pid

    +
    source

    pub fn push_on_top<T>(&self, value: T) -> *mut Twhere + T: Sized,

    Push a value on top of kernelstack

    +
    source

    pub fn get_top(&self) -> usize

    Get the value on the top of kernelstack

    +

    Trait Implementations§

    source§

    impl Drop for KernelStack

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/task/pid/struct.PID_ALLOCATOR.html b/ch5/os/task/pid/struct.PID_ALLOCATOR.html index 56acccbb..8c81702f 100644 --- a/ch5/os/task/pid/struct.PID_ALLOCATOR.html +++ b/ch5/os/task/pid/struct.PID_ALLOCATOR.html @@ -1,17 +1,14 @@ -PID_ALLOCATOR in os::task::pid - Rust

    Struct os::task::pid::PID_ALLOCATOR

    source · [−]
    pub struct PID_ALLOCATOR {
+PID_ALLOCATOR in os::task::pid - Rust
    Struct os::task::pid::PID_ALLOCATOR
    source · 
    pub struct PID_ALLOCATOR {
     __private_field: (),
-}
    Fields
    __private_field: ()
    Methods from Deref<Target = UPSafeCell<PidAllocator>>
    Exclusive access inner data in UPSafeCell. Panic if the data has been borrowed.
    
-
    Trait Implementations
    The resulting type after dereferencing.
    
-
    Dereferences the value.
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}

    Fields§

    §__private_field: ()

    Methods from Deref<Target = UPSafeCell<PidAllocator>>§

    source

    pub fn exclusive_access(&self) -> RefMut<'_, T>

    Exclusive access inner data in UPSafeCell. Panic if the data has been borrowed.

    +

    Trait Implementations§

    source§

    impl Deref for PID_ALLOCATOR

    §

    type Target = UPSafeCell<PidAllocator>

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &UPSafeCell<PidAllocator>

    Dereferences the value.
    source§

    impl LazyStatic for PID_ALLOCATOR

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/task/pid/struct.PidAllocator.html b/ch5/os/task/pid/struct.PidAllocator.html index 34d376a7..1b4855a4 100644 --- a/ch5/os/task/pid/struct.PidAllocator.html +++ b/ch5/os/task/pid/struct.PidAllocator.html @@ -1,19 +1,18 @@ -PidAllocator in os::task::pid - Rust

    Struct os::task::pid::PidAllocator

    source · [−]
    pub struct PidAllocator {
+PidAllocator in os::task::pid - Rust
    Struct os::task::pid::PidAllocator
    source · 
    pub struct PidAllocator {
     current: usize,
     recycled: Vec<usize>,
-}
    Expand description
    Pid Allocator struct
    
-
    Fields
    current: usizerecycled: Vec<usize>
    Implementations
    Create an empty PidAllocator
    
-
    Allocate a pid
    
-
    Recycle a pid
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}
    Expand description

    Pid Allocator struct

    +

    Fields§

    §current: usize§recycled: Vec<usize>

    Implementations§

    source§

    impl PidAllocator

    source

    pub fn new() -> Self

    Create an empty PidAllocator

    +
    source

    pub fn alloc(&mut self) -> PidHandle

    Allocate a pid

    +
    source

    pub fn dealloc(&mut self, pid: usize)

    Recycle a pid

    +

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/task/pid/struct.PidHandle.html b/ch5/os/task/pid/struct.PidHandle.html index fcbe37fe..2f41be36 100644 --- a/ch5/os/task/pid/struct.PidHandle.html +++ b/ch5/os/task/pid/struct.PidHandle.html @@ -1,14 +1,12 @@ -PidHandle in os::task::pid - Rust

    Struct os::task::pid::PidHandle

    source · [−]
    pub struct PidHandle(pub usize);
    Expand description

    Bind pid lifetime to PidHandle

    -

    Tuple Fields

    0: usize

    Trait Implementations

    Executes the destructor for this type. Read more

    -

    Auto Trait Implementations

    Blanket Implementations

    Gets the TypeId of self. Read more

    -

    Immutably borrows from an owned value. Read more

    -

    Mutably borrows from an owned value. Read more

    -

    Returns the argument unchanged.

    -

    Calls U::from(self).

    +PidHandle in os::task::pid - Rust

    Struct os::task::pid::PidHandle

    source · 
    pub struct PidHandle(pub usize);
    Expand description

    Bind pid lifetime to PidHandle

    +

    Tuple Fields§

    §0: usize

    Trait Implementations§

    source§

    impl Drop for PidHandle

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/task/processor/fn.current_task.html b/ch5/os/task/processor/fn.current_task.html index 0ad442d8..b89ecbb4 100644 --- a/ch5/os/task/processor/fn.current_task.html +++ b/ch5/os/task/processor/fn.current_task.html @@ -1,2 +1,2 @@ -current_task in os::task::processor - Rust

    Function os::task::processor::current_task

    source · [−]
    pub fn current_task() -> Option<Arc<TaskControlBlock>>
    Expand description

    Get running task

    -
    \ No newline at end of file +current_task in os::task::processor - Rust

    Function os::task::processor::current_task

    source · 
    pub fn current_task() -> Option<Arc<TaskControlBlock>>
    Expand description

    Get running task

    +
    \ No newline at end of file diff --git a/ch5/os/task/processor/fn.current_trap_cx.html b/ch5/os/task/processor/fn.current_trap_cx.html index 079ed8f8..2c0ef498 100644 --- a/ch5/os/task/processor/fn.current_trap_cx.html +++ b/ch5/os/task/processor/fn.current_trap_cx.html @@ -1,2 +1,2 @@ -current_trap_cx in os::task::processor - Rust

    Function os::task::processor::current_trap_cx

    source · [−]
    pub fn current_trap_cx() -> &'static mut TrapContext
    Expand description

    Get the mutable reference to trap context of current task

    -
    \ No newline at end of file +current_trap_cx in os::task::processor - Rust

    Function os::task::processor::current_trap_cx

    source · 
    pub fn current_trap_cx() -> &'static mut TrapContext
    Expand description

    Get the mutable reference to trap context of current task

    +
    \ No newline at end of file diff --git a/ch5/os/task/processor/fn.current_user_token.html b/ch5/os/task/processor/fn.current_user_token.html index 30866e32..61122ac5 100644 --- a/ch5/os/task/processor/fn.current_user_token.html +++ b/ch5/os/task/processor/fn.current_user_token.html @@ -1,2 +1,2 @@ -current_user_token in os::task::processor - Rust

    Function os::task::processor::current_user_token

    source · [−]
    pub fn current_user_token() -> usize
    Expand description

    Get token of the address space of current task

    -
    \ No newline at end of file +current_user_token in os::task::processor - Rust

    Function os::task::processor::current_user_token

    source · 
    pub fn current_user_token() -> usize
    Expand description

    Get token of the address space of current task

    +
    \ No newline at end of file diff --git a/ch5/os/task/processor/fn.run_tasks.html b/ch5/os/task/processor/fn.run_tasks.html index 0c1ba19b..d8a6d6cc 100644 --- a/ch5/os/task/processor/fn.run_tasks.html +++ b/ch5/os/task/processor/fn.run_tasks.html @@ -1,3 +1,3 @@ -run_tasks in os::task::processor - Rust

    Function os::task::processor::run_tasks

    source · [−]
    pub fn run_tasks()
    Expand description

    The main part of process execution and scheduling +run_tasks in os::task::processor - Rust

    Function os::task::processor::run_tasks

    source · 
    pub fn run_tasks()
    Expand description

    The main part of process execution and scheduling Loop fetch_task to get the process that needs to run, and switch the process through __switch

    -
    \ No newline at end of file +
    \ No newline at end of file diff --git a/ch5/os/task/processor/fn.schedule.html b/ch5/os/task/processor/fn.schedule.html index bc208326..02470d31 100644 --- a/ch5/os/task/processor/fn.schedule.html +++ b/ch5/os/task/processor/fn.schedule.html @@ -1,2 +1,2 @@ -schedule in os::task::processor - Rust

    Function os::task::processor::schedule

    source · [−]
    pub fn schedule(switched_task_cx_ptr: *mut TaskContext)
    Expand description

    Return to idle control flow for new scheduling

    -
    \ No newline at end of file +schedule in os::task::processor - Rust

    Function os::task::processor::schedule

    source · 
    pub fn schedule(switched_task_cx_ptr: *mut TaskContext)
    Expand description

    Return to idle control flow for new scheduling

    +
    \ No newline at end of file diff --git a/ch5/os/task/processor/fn.take_current_task.html b/ch5/os/task/processor/fn.take_current_task.html index 51be80b1..8545c8cf 100644 --- a/ch5/os/task/processor/fn.take_current_task.html +++ b/ch5/os/task/processor/fn.take_current_task.html @@ -1,2 +1,2 @@ -take_current_task in os::task::processor - Rust

    Function os::task::processor::take_current_task

    source · [−]
    pub fn take_current_task() -> Option<Arc<TaskControlBlock>>
    Expand description

    Take the current task,leaving a None in its place

    -
    \ No newline at end of file +take_current_task in os::task::processor - Rust

    Function os::task::processor::take_current_task

    source · 
    pub fn take_current_task() -> Option<Arc<TaskControlBlock>>
    Expand description

    Take the current task,leaving a None in its place

    +
    \ No newline at end of file diff --git a/ch5/os/task/processor/index.html b/ch5/os/task/processor/index.html index 5b40bae6..ed6018f8 100644 --- a/ch5/os/task/processor/index.html +++ b/ch5/os/task/processor/index.html @@ -1,10 +1,3 @@ -os::task::processor - Rust

    Module os::task::processor

    source · [−]
    Expand description

    Implementation of Processor and Intersection of control flow

    -

    Structs

    PROCESSOR
    Processor

    Processor management structure

    -

    Functions

    current_task

    Get running task

    -
    current_trap_cx

    Get the mutable reference to trap context of current task

    -
    current_user_token

    Get token of the address space of current task

    -
    run_tasks

    The main part of process execution and scheduling -Loop fetch_task to get the process that needs to run, and switch the process through __switch

    -
    schedule

    Return to idle control flow for new scheduling

    -
    take_current_task

    Take the current task,leaving a None in its place

    -
    \ No newline at end of file +os::task::processor - Rust

    Module os::task::processor

    source ·
    Expand description

    Implementation of Processor and Intersection of control flow

    +

    Structs

    Functions

    • current_task
      Get running task
    • current_trap_cx
      Get the mutable reference to trap context of current task
    • current_user_token
      Get token of the address space of current task
    • run_tasks
      The main part of process execution and scheduling +Loop fetch_task to get the process that needs to run, and switch the process through __switch
    • schedule
      Return to idle control flow for new scheduling
    • take_current_task
      Take the current task,leaving a None in its place
    \ No newline at end of file diff --git a/ch5/os/task/processor/sidebar-items.js b/ch5/os/task/processor/sidebar-items.js index b6e62833..567a9a18 100644 --- a/ch5/os/task/processor/sidebar-items.js +++ b/ch5/os/task/processor/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"fn":[["current_task","Get running task"],["current_trap_cx","Get the mutable reference to trap context of current task"],["current_user_token","Get token of the address space of current task"],["run_tasks","The main part of process execution and scheduling Loop `fetch_task` to get the process that needs to run, and switch the process through `__switch`"],["schedule","Return to idle control flow for new scheduling"],["take_current_task","Take the current task,leaving a None in its place"]],"struct":[["PROCESSOR",""],["Processor","Processor management structure"]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"fn":["current_task","current_trap_cx","current_user_token","run_tasks","schedule","take_current_task"],"struct":["PROCESSOR","Processor"]}; \ No newline at end of file diff --git a/ch5/os/task/processor/struct.PROCESSOR.html b/ch5/os/task/processor/struct.PROCESSOR.html index 6e1ac655..37b4b4fc 100644 --- a/ch5/os/task/processor/struct.PROCESSOR.html +++ b/ch5/os/task/processor/struct.PROCESSOR.html @@ -1,17 +1,14 @@ -PROCESSOR in os::task::processor - Rust

    Struct os::task::processor::PROCESSOR

    source · [−]
    pub struct PROCESSOR {
+PROCESSOR in os::task::processor - Rust
    Struct os::task::processor::PROCESSOR
    source · 
    pub struct PROCESSOR {
     __private_field: (),
-}
    Fields
    __private_field: ()
    Methods from Deref<Target = UPSafeCell<Processor>>
    Exclusive access inner data in UPSafeCell. Panic if the data has been borrowed.
    
-
    Trait Implementations
    The resulting type after dereferencing.
    
-
    Dereferences the value.
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}

    Fields§

    §__private_field: ()

    Methods from Deref<Target = UPSafeCell<Processor>>§

    source

    pub fn exclusive_access(&self) -> RefMut<'_, T>

    Exclusive access inner data in UPSafeCell. Panic if the data has been borrowed.

    +

    Trait Implementations§

    source§

    impl Deref for PROCESSOR

    §

    type Target = UPSafeCell<Processor>

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &UPSafeCell<Processor>

    Dereferences the value.
    source§

    impl LazyStatic for PROCESSOR

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/task/processor/struct.Processor.html b/ch5/os/task/processor/struct.Processor.html index 4e5e909b..fd743a7d 100644 --- a/ch5/os/task/processor/struct.Processor.html +++ b/ch5/os/task/processor/struct.Processor.html @@ -1,22 +1,21 @@ -Processor in os::task::processor - Rust

    Struct os::task::processor::Processor

    source · [−]
    pub struct Processor {
+Processor in os::task::processor - Rust
    Struct os::task::processor::Processor
    source · 
    pub struct Processor {
     current: Option<Arc<TaskControlBlock>>,
     idle_task_cx: TaskContext,
-}
    Expand description
    Processor management structure
    
-
    Fields
    current: Option<Arc<TaskControlBlock>>
    The task currently executing on the current processor
    
-
    idle_task_cx: TaskContext
    The basic control flow of each core, helping to select and switch process
    
-
    Implementations
    Create an empty Processor
    
-
    Get mutable reference to idle_task_cx
    
-
    Get current task in moving semanteme
    
-
    Get current task in cloning semanteme
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}
    Expand description

    Processor management structure

    +

    Fields§

    §current: Option<Arc<TaskControlBlock>>

    The task currently executing on the current processor

    +
    §idle_task_cx: TaskContext

    The basic control flow of each core, helping to select and switch process

    +

    Implementations§

    source§

    impl Processor

    source

    pub fn new() -> Self

    Create an empty Processor

    +
    source

    fn get_idle_task_cx_ptr(&mut self) -> *mut TaskContext

    Get mutable reference to idle_task_cx

    +
    source

    pub fn take_current(&mut self) -> Option<Arc<TaskControlBlock>>

    Get current task in moving semanteme

    +
    source

    pub fn current(&self) -> Option<Arc<TaskControlBlock>>

    Get current task in cloning semanteme

    +

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/task/sidebar-items.js b/ch5/os/task/sidebar-items.js index c1b4a81b..d5317e17 100644 --- a/ch5/os/task/sidebar-items.js +++ b/ch5/os/task/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"constant":[["IDLE_PID","pid of usertests app in make run TEST=1"]],"fn":[["add_initproc","Add init process to the manager"],["add_task","Interface offered to add task"],["current_task","Get running task"],["current_trap_cx","Get the mutable reference to trap context of current task"],["current_user_token","Get token of the address space of current task"],["exit_current_and_run_next","Exit the current ‘Running’ task and run the next task in task list."],["fetch_task","Interface offered to pop the first task"],["pid_alloc","Allocate a pid from PID_ALLOCATOR"],["run_tasks","The main part of process execution and scheduling Loop `fetch_task` to get the process that needs to run, and switch the process through `__switch`"],["schedule","Return to idle control flow for new scheduling"],["suspend_current_and_run_next","Suspend the current ‘Running’ task and run the next task in task list."],["take_current_task","Take the current task,leaving a None in its place"]],"mod":[["context","Implementation of [`TaskContext`]"],["manager","Implementation of [`TaskManager`]"],["pid","Implementation of [`PidAllocator`]"],["processor","Implementation of [`Processor`] and Intersection of control flow"],["switch","Wrap `switch.S` as a function"],["task","Implementation of [`TaskControlBlock`]"]],"struct":[["INITPROC","Globle process that init user shell"],["KernelStack","Kernelstack for app"],["PidAllocator","Pid Allocator struct"],["PidHandle","Bind pid lifetime to `PidHandle`"],["Processor","Processor management structure"],["TaskContext","task context structure containing some registers"],["TaskManager","A array of `TaskControlBlock` that is thread-safe"]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"constant":["IDLE_PID"],"fn":["add_initproc","add_task","current_task","current_trap_cx","current_user_token","exit_current_and_run_next","fetch_task","pid_alloc","run_tasks","schedule","suspend_current_and_run_next","take_current_task"],"mod":["context","manager","pid","processor","switch","task"],"struct":["INITPROC","KernelStack","PidAllocator","PidHandle","Processor","TaskContext","TaskManager"]}; \ No newline at end of file diff --git a/ch5/os/task/struct.INITPROC.html b/ch5/os/task/struct.INITPROC.html index 371e8a66..78f862b3 100644 --- a/ch5/os/task/struct.INITPROC.html +++ b/ch5/os/task/struct.INITPROC.html @@ -1,17 +1,14 @@ -INITPROC in os::task - Rust

    Struct os::task::INITPROC

    source · [−]
    pub struct INITPROC {
+INITPROC in os::task - Rust
    Struct os::task::INITPROC
    source · 
    pub struct INITPROC {
     __private_field: (),
-}
    Expand description
    Globle process that init user shell
    
-
    Fields
    __private_field: ()
    Trait Implementations
    The resulting type after dereferencing.
    
-
    Dereferences the value.
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}
    Expand description

    Globle process that init user shell

    +

    Fields§

    §__private_field: ()

    Trait Implementations§

    source§

    impl Deref for INITPROC

    §

    type Target = Arc<TaskControlBlock, Global>

    The resulting type after dereferencing.
    source§

    fn deref(&self) -> &Arc<TaskControlBlock>

    Dereferences the value.
    source§

    impl LazyStatic for INITPROC

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/task/struct.KernelStack.html b/ch5/os/task/struct.KernelStack.html index ab970faa..3d4f1c11 100644 --- a/ch5/os/task/struct.KernelStack.html +++ b/ch5/os/task/struct.KernelStack.html @@ -1,19 +1,18 @@ -KernelStack in os::task - Rust

    Struct os::task::KernelStack

    source · [−]
    pub struct KernelStack {
+KernelStack in os::task - Rust
    Struct os::task::KernelStack
    source · 
    pub struct KernelStack {
     pid: usize,
-}
    Expand description
    Kernelstack for app
    
-
    Fields
    pid: usize
    Implementations
    Create a kernelstack from pid
    
-
    Push a value on top of kernelstack
    
-
    Get the value on the top of kernelstack
    
-
    Trait Implementations
    Executes the destructor for this type. Read more
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}
    Expand description

    Kernelstack for app

    +

    Fields§

    §pid: usize

    Implementations§

    source§

    impl KernelStack

    source

    pub fn new(pid_handle: &PidHandle) -> Self

    Create a kernelstack from pid

    +
    source

    pub fn push_on_top<T>(&self, value: T) -> *mut Twhere + T: Sized,

    Push a value on top of kernelstack

    +
    source

    pub fn get_top(&self) -> usize

    Get the value on the top of kernelstack

    +

    Trait Implementations§

    source§

    impl Drop for KernelStack

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/task/struct.PidAllocator.html b/ch5/os/task/struct.PidAllocator.html index 8d2eb107..e00c1cc6 100644 --- a/ch5/os/task/struct.PidAllocator.html +++ b/ch5/os/task/struct.PidAllocator.html @@ -1,19 +1,18 @@ -PidAllocator in os::task - Rust

    Struct os::task::PidAllocator

    source · [−]
    pub struct PidAllocator {
+PidAllocator in os::task - Rust
    Struct os::task::PidAllocator
    source · 
    pub struct PidAllocator {
     current: usize,
     recycled: Vec<usize>,
-}
    Expand description
    Pid Allocator struct
    
-
    Fields
    current: usizerecycled: Vec<usize>
    Implementations
    Create an empty PidAllocator
    
-
    Allocate a pid
    
-
    Recycle a pid
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}
    Expand description

    Pid Allocator struct

    +

    Fields§

    §current: usize§recycled: Vec<usize>

    Implementations§

    source§

    impl PidAllocator

    source

    pub fn new() -> Self

    Create an empty PidAllocator

    +
    source

    pub fn alloc(&mut self) -> PidHandle

    Allocate a pid

    +
    source

    pub fn dealloc(&mut self, pid: usize)

    Recycle a pid

    +

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/task/struct.PidHandle.html b/ch5/os/task/struct.PidHandle.html index 9450fa6e..cc55ffe7 100644 --- a/ch5/os/task/struct.PidHandle.html +++ b/ch5/os/task/struct.PidHandle.html @@ -1,14 +1,12 @@ -PidHandle in os::task - Rust

    Struct os::task::PidHandle

    source · [−]
    pub struct PidHandle(pub usize);
    Expand description

    Bind pid lifetime to PidHandle

    -

    Tuple Fields

    0: usize

    Trait Implementations

    Executes the destructor for this type. Read more

    -

    Auto Trait Implementations

    Blanket Implementations

    Gets the TypeId of self. Read more

    -

    Immutably borrows from an owned value. Read more

    -

    Mutably borrows from an owned value. Read more

    -

    Returns the argument unchanged.

    -

    Calls U::from(self).

    +PidHandle in os::task - Rust

    Struct os::task::PidHandle

    source · 
    pub struct PidHandle(pub usize);
    Expand description

    Bind pid lifetime to PidHandle

    +

    Tuple Fields§

    §0: usize

    Trait Implementations§

    source§

    impl Drop for PidHandle

    source§

    fn drop(&mut self)

    Executes the destructor for this type. Read more

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/task/struct.Processor.html b/ch5/os/task/struct.Processor.html index 30d3c8ed..b982e912 100644 --- a/ch5/os/task/struct.Processor.html +++ b/ch5/os/task/struct.Processor.html @@ -1,22 +1,21 @@ -Processor in os::task - Rust

    Struct os::task::Processor

    source · [−]
    pub struct Processor {
+Processor in os::task - Rust
    Struct os::task::Processor
    source · 
    pub struct Processor {
     current: Option<Arc<TaskControlBlock>>,
     idle_task_cx: TaskContext,
-}
    Expand description
    Processor management structure
    
-
    Fields
    current: Option<Arc<TaskControlBlock>>
    The task currently executing on the current processor
    
-
    idle_task_cx: TaskContext
    The basic control flow of each core, helping to select and switch process
    
-
    Implementations
    Create an empty Processor
    
-
    Get mutable reference to idle_task_cx
    
-
    Get current task in moving semanteme
    
-
    Get current task in cloning semanteme
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}
    Expand description

    Processor management structure

    +

    Fields§

    §current: Option<Arc<TaskControlBlock>>

    The task currently executing on the current processor

    +
    §idle_task_cx: TaskContext

    The basic control flow of each core, helping to select and switch process

    +

    Implementations§

    source§

    impl Processor

    source

    pub fn new() -> Self

    Create an empty Processor

    +
    source

    fn get_idle_task_cx_ptr(&mut self) -> *mut TaskContext

    Get mutable reference to idle_task_cx

    +
    source

    pub fn take_current(&mut self) -> Option<Arc<TaskControlBlock>>

    Get current task in moving semanteme

    +
    source

    pub fn current(&self) -> Option<Arc<TaskControlBlock>>

    Get current task in cloning semanteme

    +

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/task/struct.TaskContext.html b/ch5/os/task/struct.TaskContext.html index 3648e800..67729232 100644 --- a/ch5/os/task/struct.TaskContext.html +++ b/ch5/os/task/struct.TaskContext.html @@ -1,22 +1,21 @@ -TaskContext in os::task - Rust

    Struct os::task::TaskContext

    source · [−]
    #[repr(C)]
    pub struct TaskContext {
+TaskContext in os::task - Rust
    Struct os::task::TaskContext
    source · 
    #[repr(C)]
    pub struct TaskContext {
     ra: usize,
     sp: usize,
-    s: [usize; 12],
-}
    Expand description
    task context structure containing some registers
    
-
    Fields
    ra: usize
    return address ( e.g. __restore ) of __switch ASM function
    
-
    sp: usize
    kernel stack pointer of app
    
-
    s: [usize; 12]
    s0-11 register, callee saved
    
-
    Implementations
    init task context
    
-
    set Task Context{__restore ASM funciton: trap_return, sp: kstack_ptr, s: s_0..12}
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+    s: [usize; 12],
+}
    Expand description

    task context structure containing some registers

    +

    Fields§

    §ra: usize

    return address ( e.g. __restore ) of __switch ASM function

    +
    §sp: usize

    kernel stack pointer of app

    +
    §s: [usize; 12]

    s0-11 register, callee saved

    +

    Implementations§

    source§

    impl TaskContext

    source

    pub fn zero_init() -> Self

    init task context

    +
    source

    pub fn goto_trap_return(kstack_ptr: usize) -> Self

    set Task Context{__restore ASM funciton: trap_return, sp: kstack_ptr, s: s_0..12}

    +

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/task/struct.TaskManager.html b/ch5/os/task/struct.TaskManager.html index d5c6e460..a904b98f 100644 --- a/ch5/os/task/struct.TaskManager.html +++ b/ch5/os/task/struct.TaskManager.html @@ -1,19 +1,18 @@ -TaskManager in os::task - Rust

    Struct os::task::TaskManager

    source · [−]
    pub struct TaskManager {
+TaskManager in os::task - Rust
    Struct os::task::TaskManager
    source · 
    pub struct TaskManager {
     ready_queue: VecDeque<Arc<TaskControlBlock>>,
-}
    Expand description
    A array of TaskControlBlock that is thread-safe
    
-
    Fields
    ready_queue: VecDeque<Arc<TaskControlBlock>>
    Implementations
    A simple FIFO scheduler.
    
-
    Creat an empty TaskManager
    
-
    Add a task to TaskManager
    
-
    Remove the first task and return it,or None if TaskManager is empty
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}
    Expand description

    A array of TaskControlBlock that is thread-safe

    +

    Fields§

    §ready_queue: VecDeque<Arc<TaskControlBlock>>

    Implementations§

    source§

    impl TaskManager

    A simple FIFO scheduler.

    +
    source

    pub fn new() -> Self

    Creat an empty TaskManager

    +
    source

    pub fn add(&mut self, task: Arc<TaskControlBlock>)

    Add a task to TaskManager

    +
    source

    pub fn fetch(&mut self) -> Option<Arc<TaskControlBlock>>

    Remove the first task and return it,or None if TaskManager is empty

    +

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/task/switch/fn.__switch.html b/ch5/os/task/switch/fn.__switch.html index f6de6956..fe2ca3b4 100644 --- a/ch5/os/task/switch/fn.__switch.html +++ b/ch5/os/task/switch/fn.__switch.html @@ -1 +1,4 @@ -__switch in os::task::switch - Rust

    Function os::task::switch::__switch

    source · [−]
    pub unsafe extern "C" fn __switch(
        current_task_cx_ptr: *mut TaskContext,
        next_task_cx_ptr: *const TaskContext
    )
    \ No newline at end of file +__switch in os::task::switch - Rust

    Function os::task::switch::__switch

    source · 
    pub unsafe extern "C" fn __switch(
+    current_task_cx_ptr: *mut TaskContext,
+    next_task_cx_ptr: *const TaskContext
+)
    \ No newline at end of file diff --git a/ch5/os/task/switch/index.html b/ch5/os/task/switch/index.html index 5d71f760..a5a5f151 100644 --- a/ch5/os/task/switch/index.html +++ b/ch5/os/task/switch/index.html @@ -1,2 +1,2 @@ -os::task::switch - Rust

    Module os::task::switch

    source · [−]
    Expand description

    Wrap switch.S as a function

    -

    Functions

    __switch⚠
    \ No newline at end of file +os::task::switch - Rust

    Module os::task::switch

    source ·
    Expand description

    Wrap switch.S as a function

    +

    Functions

    \ No newline at end of file diff --git a/ch5/os/task/switch/sidebar-items.js b/ch5/os/task/switch/sidebar-items.js index 28ba182b..8dea751a 100644 --- a/ch5/os/task/switch/sidebar-items.js +++ b/ch5/os/task/switch/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"fn":[["__switch",""]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"fn":["__switch"]}; \ No newline at end of file diff --git a/ch5/os/task/task/enum.TaskStatus.html b/ch5/os/task/task/enum.TaskStatus.html index 320d4d1f..a18af3f8 100644 --- a/ch5/os/task/task/enum.TaskStatus.html +++ b/ch5/os/task/task/enum.TaskStatus.html @@ -1,24 +1,18 @@ -TaskStatus in os::task::task - Rust

    Enum os::task::task::TaskStatus

    source · [−]
    pub enum TaskStatus {
+TaskStatus in os::task::task - Rust
    Enum os::task::task::TaskStatus
    source · 
    pub enum TaskStatus {
     Ready,
     Running,
     Zombie,
-}
    Variants
    Ready
    Running
    Zombie
    Trait Implementations
    Returns a copy of the value. Read more
    
-
    Performs copy-assignment from source. Read more
    
-
    This method tests for self and other values to be equal, and is used
-by ==. Read more
    
-
    This method tests for !=.
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}

    Variants§

    §

    Ready

    §

    Running

    §

    Zombie

    Trait Implementations§

    source§

    impl Clone for TaskStatus

    source§

    fn clone(&self) -> TaskStatus

    Returns a copy of the value. Read more
    1.0.0 · source§

    fn clone_from(&mut self, source: &Self)

    Performs copy-assignment from source. Read more
    source§

    impl PartialEq<TaskStatus> for TaskStatus

    source§

    fn eq(&self, other: &TaskStatus) -> bool

    This method tests for self and other values to be equal, and is used +by ==.
    1.0.0 · source§

    fn ne(&self, other: &Rhs) -> bool

    This method tests for !=. The default implementation is almost always +sufficient, and should not be overridden without very good reason.
    source§

    impl Copy for TaskStatus

    source§

    impl StructuralPartialEq for TaskStatus

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The resulting type after obtaining ownership.

    -

    Creates owned data from borrowed data, usually by cloning. Read more

    -

    Uses borrowed data to replace owned data, usually by cloning. Read more

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T> ToOwned for Twhere + T: Clone,

    §

    type Owned = T

    The resulting type after obtaining ownership.
    source§

    fn to_owned(&self) -> T

    Creates owned data from borrowed data, usually by cloning. Read more
    source§

    fn clone_into(&self, target: &mut T)

    Uses borrowed data to replace owned data, usually by cloning. Read more
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/task/task/index.html b/ch5/os/task/task/index.html index e4431382..f1aac1f7 100644 --- a/ch5/os/task/task/index.html +++ b/ch5/os/task/task/index.html @@ -1,2 +1,2 @@ -os::task::task - Rust

    Module os::task::task

    source · [−]
    Expand description

    Implementation of TaskControlBlock

    -

    Structs

    TaskControlBlock
    TaskControlBlockInner

    Enums

    TaskStatus
    \ No newline at end of file +os::task::task - Rust

    Module os::task::task

    source ·
    Expand description

    Implementation of TaskControlBlock

    +

    Structs

    Enums

    \ No newline at end of file diff --git a/ch5/os/task/task/sidebar-items.js b/ch5/os/task/task/sidebar-items.js index 272090ba..e3e27912 100644 --- a/ch5/os/task/task/sidebar-items.js +++ b/ch5/os/task/task/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"enum":[["TaskStatus",""]],"struct":[["TaskControlBlock",""],["TaskControlBlockInner",""]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"enum":["TaskStatus"],"struct":["TaskControlBlock","TaskControlBlockInner"]}; \ No newline at end of file diff --git a/ch5/os/task/task/struct.TaskControlBlock.html b/ch5/os/task/task/struct.TaskControlBlock.html index 76b564d8..13111059 100644 --- a/ch5/os/task/task/struct.TaskControlBlock.html +++ b/ch5/os/task/task/struct.TaskControlBlock.html @@ -1,16 +1,15 @@ -TaskControlBlock in os::task::task - Rust

    Struct os::task::task::TaskControlBlock

    source · [−]
    pub struct TaskControlBlock {
+TaskControlBlock in os::task::task - Rust
    Struct os::task::task::TaskControlBlock
    source · 
    pub struct TaskControlBlock {
     pub pid: PidHandle,
     pub kernel_stack: KernelStack,
     inner: UPSafeCell<TaskControlBlockInner>,
-}
    Fields
    pid: PidHandlekernel_stack: KernelStackinner: UPSafeCell<TaskControlBlockInner>
    Implementations
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}

    Fields§

    §pid: PidHandle§kernel_stack: KernelStack§inner: UPSafeCell<TaskControlBlockInner>

    Implementations§

    source§

    impl TaskControlBlock

    source

    pub fn inner_exclusive_access(&self) -> RefMut<'_, TaskControlBlockInner>

    source

    pub fn new(elf_data: &[u8]) -> Self

    source

    pub fn exec(&self, elf_data: &[u8])

    source

    pub fn fork(self: &Arc<Self>) -> Arc<Self>

    source

    pub fn getpid(&self) -> usize

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/task/task/struct.TaskControlBlockInner.html b/ch5/os/task/task/struct.TaskControlBlockInner.html index a3d5dc46..504d52df 100644 --- a/ch5/os/task/task/struct.TaskControlBlockInner.html +++ b/ch5/os/task/task/struct.TaskControlBlockInner.html @@ -1,4 +1,4 @@ -TaskControlBlockInner in os::task::task - Rust

    Struct os::task::task::TaskControlBlockInner

    source · [−]
    pub struct TaskControlBlockInner {
+TaskControlBlockInner in os::task::task - Rust
    Struct os::task::task::TaskControlBlockInner
    source · 
    pub struct TaskControlBlockInner {
     pub trap_cx_ppn: PhysPageNum,
     pub base_size: usize,
     pub task_cx: TaskContext,
@@ -7,15 +7,14 @@
     pub parent: Option<Weak<TaskControlBlock>>,
     pub children: Vec<Arc<TaskControlBlock>>,
     pub exit_code: i32,
-}
    Fields
    trap_cx_ppn: PhysPageNumbase_size: usizetask_cx: TaskContexttask_status: TaskStatusmemory_set: MemorySetparent: Option<Weak<TaskControlBlock>>children: Vec<Arc<TaskControlBlock>>exit_code: i32
    Implementations
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}

    Fields§

    §trap_cx_ppn: PhysPageNum§base_size: usize§task_cx: TaskContext§task_status: TaskStatus§memory_set: MemorySet§parent: Option<Weak<TaskControlBlock>>§children: Vec<Arc<TaskControlBlock>>§exit_code: i32

    Implementations§

    source§

    impl TaskControlBlockInner

    source

    pub fn get_trap_cx(&self) -> &'static mut TrapContext

    source

    pub fn get_user_token(&self) -> usize

    source

    fn get_status(&self) -> TaskStatus

    source

    pub fn is_zombie(&self) -> bool

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/timer/constant.MSEC_PER_SEC.html b/ch5/os/timer/constant.MSEC_PER_SEC.html index b225d5c1..38b28724 100644 --- a/ch5/os/timer/constant.MSEC_PER_SEC.html +++ b/ch5/os/timer/constant.MSEC_PER_SEC.html @@ -1 +1 @@ -MSEC_PER_SEC in os::timer - Rust

    Constant os::timer::MSEC_PER_SEC

    source · [−]
    const MSEC_PER_SEC: usize = 1000;
    \ No newline at end of file +MSEC_PER_SEC in os::timer - Rust

    Constant os::timer::MSEC_PER_SEC

    source · 
    const MSEC_PER_SEC: usize = 1000;
    \ No newline at end of file diff --git a/ch5/os/timer/constant.TICKS_PER_SEC.html b/ch5/os/timer/constant.TICKS_PER_SEC.html index d61f9ec0..13cd686d 100644 --- a/ch5/os/timer/constant.TICKS_PER_SEC.html +++ b/ch5/os/timer/constant.TICKS_PER_SEC.html @@ -1 +1 @@ -TICKS_PER_SEC in os::timer - Rust

    Constant os::timer::TICKS_PER_SEC

    source · [−]
    const TICKS_PER_SEC: usize = 100;
    \ No newline at end of file +TICKS_PER_SEC in os::timer - Rust

    Constant os::timer::TICKS_PER_SEC

    source · 
    const TICKS_PER_SEC: usize = 100;
    \ No newline at end of file diff --git a/ch5/os/timer/fn.get_time.html b/ch5/os/timer/fn.get_time.html index 72baf358..824ae03f 100644 --- a/ch5/os/timer/fn.get_time.html +++ b/ch5/os/timer/fn.get_time.html @@ -1,2 +1,2 @@ -get_time in os::timer - Rust

    Function os::timer::get_time

    source · [−]
    pub fn get_time() -> usize
    Expand description

    get current time

    -
    \ No newline at end of file +get_time in os::timer - Rust

    Function os::timer::get_time

    source · 
    pub fn get_time() -> usize
    Expand description

    get current time

    +
    \ No newline at end of file diff --git a/ch5/os/timer/fn.get_time_ms.html b/ch5/os/timer/fn.get_time_ms.html index 68e63c45..e6805486 100644 --- a/ch5/os/timer/fn.get_time_ms.html +++ b/ch5/os/timer/fn.get_time_ms.html @@ -1,2 +1,2 @@ -get_time_ms in os::timer - Rust

    Function os::timer::get_time_ms

    source · [−]
    pub fn get_time_ms() -> usize
    Expand description

    get current time in microseconds

    -
    \ No newline at end of file +get_time_ms in os::timer - Rust

    Function os::timer::get_time_ms

    source · 
    pub fn get_time_ms() -> usize
    Expand description

    get current time in microseconds

    +
    \ No newline at end of file diff --git a/ch5/os/timer/fn.set_next_trigger.html b/ch5/os/timer/fn.set_next_trigger.html index 8e504372..ae5c305c 100644 --- a/ch5/os/timer/fn.set_next_trigger.html +++ b/ch5/os/timer/fn.set_next_trigger.html @@ -1,2 +1,2 @@ -set_next_trigger in os::timer - Rust

    Function os::timer::set_next_trigger

    source · [−]
    pub fn set_next_trigger()
    Expand description

    set the next timer interrupt

    -
    \ No newline at end of file +set_next_trigger in os::timer - Rust

    Function os::timer::set_next_trigger

    source · 
    pub fn set_next_trigger()
    Expand description

    set the next timer interrupt

    +
    \ No newline at end of file diff --git a/ch5/os/timer/index.html b/ch5/os/timer/index.html index 5a0742df..3163dace 100644 --- a/ch5/os/timer/index.html +++ b/ch5/os/timer/index.html @@ -1,5 +1,2 @@ -os::timer - Rust

    Module os::timer

    source · [−]
    Expand description

    RISC-V timer-related functionality

    -

    Constants

    MSEC_PER_SEC 🔒
    TICKS_PER_SEC 🔒

    Functions

    get_time

    get current time

    -
    get_time_ms

    get current time in microseconds

    -
    set_next_trigger

    set the next timer interrupt

    -
    \ No newline at end of file +os::timer - Rust

    Module os::timer

    source ·
    Expand description

    RISC-V timer-related functionality

    +

    Constants

    Functions

    \ No newline at end of file diff --git a/ch5/os/timer/sidebar-items.js b/ch5/os/timer/sidebar-items.js index 0a4fc292..bf5ff37b 100644 --- a/ch5/os/timer/sidebar-items.js +++ b/ch5/os/timer/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"constant":[["MSEC_PER_SEC",""],["TICKS_PER_SEC",""]],"fn":[["get_time","get current time"],["get_time_ms","get current time in microseconds"],["set_next_trigger","set the next timer interrupt"]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"constant":["MSEC_PER_SEC","TICKS_PER_SEC"],"fn":["get_time","get_time_ms","set_next_trigger"]}; \ No newline at end of file diff --git a/ch5/os/trap/context/index.html b/ch5/os/trap/context/index.html index d8c3b3a5..2eb0a37d 100644 --- a/ch5/os/trap/context/index.html +++ b/ch5/os/trap/context/index.html @@ -1,3 +1,2 @@ -os::trap::context - Rust

    Module os::trap::context

    source · [−]
    Expand description

    Implementation of TrapContext

    -

    Structs

    TrapContext

    trap context structure containing sstatus, sepc and registers

    -
    \ No newline at end of file +os::trap::context - Rust

    Module os::trap::context

    source ·
    Expand description

    Implementation of TrapContext

    +

    Structs

    • TrapContext
      trap context structure containing sstatus, sepc and registers
    \ No newline at end of file diff --git a/ch5/os/trap/context/sidebar-items.js b/ch5/os/trap/context/sidebar-items.js index 2933c8a8..920f7c9e 100644 --- a/ch5/os/trap/context/sidebar-items.js +++ b/ch5/os/trap/context/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"struct":[["TrapContext","trap context structure containing sstatus, sepc and registers"]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"struct":["TrapContext"]}; \ No newline at end of file diff --git a/ch5/os/trap/context/struct.TrapContext.html b/ch5/os/trap/context/struct.TrapContext.html index 125f0b9f..4e1c34ac 100644 --- a/ch5/os/trap/context/struct.TrapContext.html +++ b/ch5/os/trap/context/struct.TrapContext.html @@ -1,28 +1,33 @@ -TrapContext in os::trap::context - Rust

    Struct os::trap::context::TrapContext

    source · [−]
    #[repr(C)]
    pub struct TrapContext {
-    pub x: [usize; 32],
+TrapContext in os::trap::context - Rust
    Struct os::trap::context::TrapContext
    source · 
    #[repr(C)]
    pub struct TrapContext {
+    pub x: [usize; 32],
     pub sstatus: Sstatus,
     pub sepc: usize,
     pub kernel_satp: usize,
     pub kernel_sp: usize,
     pub trap_handler: usize,
-}
    Expand description
    trap context structure containing sstatus, sepc and registers
    
-
    Fields
    x: [usize; 32]
    general regs[0..31]
    
-
    sstatus: Sstatus
    CSR sstatus      
    
-
    sepc: usize
    CSR sepc
    
-
    kernel_satp: usize
    Addr of Page Table
    
-
    kernel_sp: usize
    kernel stack
    
-
    trap_handler: usize
    Addr of trap_handler function
    
-
    Implementations
    set stack pointer to x_2 reg (sp)
    
-
    init app context
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}
    Expand description

    trap context structure containing sstatus, sepc and registers

    +

    Fields§

    §x: [usize; 32]

    general regs[0..31]

    +
    §sstatus: Sstatus

    CSR sstatus

    +
    §sepc: usize

    CSR sepc

    +
    §kernel_satp: usize

    Addr of Page Table

    +
    §kernel_sp: usize

    kernel stack

    +
    §trap_handler: usize

    Addr of trap_handler function

    +

    Implementations§

    source§

    impl TrapContext

    source

    pub fn set_sp(&mut self, sp: usize)

    set stack pointer to x_2 reg (sp)

    +
    source

    pub fn app_init_context( + entry: usize, + sp: usize, + kernel_satp: usize, + kernel_sp: usize, + trap_handler: usize +) -> Self

    init app context

    +

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/os/trap/fn.enable_timer_interrupt.html b/ch5/os/trap/fn.enable_timer_interrupt.html index 8777adec..9f286f5c 100644 --- a/ch5/os/trap/fn.enable_timer_interrupt.html +++ b/ch5/os/trap/fn.enable_timer_interrupt.html @@ -1,2 +1,2 @@ -enable_timer_interrupt in os::trap - Rust

    Function os::trap::enable_timer_interrupt

    source · [−]
    pub fn enable_timer_interrupt()
    Expand description

    enable timer interrupt in sie CSR

    -
    \ No newline at end of file +enable_timer_interrupt in os::trap - Rust

    Function os::trap::enable_timer_interrupt

    source · 
    pub fn enable_timer_interrupt()
    Expand description

    enable timer interrupt in sie CSR

    +
    \ No newline at end of file diff --git a/ch5/os/trap/fn.init.html b/ch5/os/trap/fn.init.html index 58c7bd2f..4a472035 100644 --- a/ch5/os/trap/fn.init.html +++ b/ch5/os/trap/fn.init.html @@ -1,2 +1,2 @@ -init in os::trap - Rust

    Function os::trap::init

    source · [−]
    pub fn init()
    Expand description

    initialize CSR stvec as the entry of __alltraps

    -
    \ No newline at end of file +init in os::trap - Rust

    Function os::trap::init

    source · 
    pub fn init()
    Expand description

    initialize CSR stvec as the entry of __alltraps

    +
    \ No newline at end of file diff --git a/ch5/os/trap/fn.set_kernel_trap_entry.html b/ch5/os/trap/fn.set_kernel_trap_entry.html index c92c8a41..601fb857 100644 --- a/ch5/os/trap/fn.set_kernel_trap_entry.html +++ b/ch5/os/trap/fn.set_kernel_trap_entry.html @@ -1 +1 @@ -set_kernel_trap_entry in os::trap - Rust

    Function os::trap::set_kernel_trap_entry

    source · [−]
    fn set_kernel_trap_entry()
    \ No newline at end of file +set_kernel_trap_entry in os::trap - Rust

    Function os::trap::set_kernel_trap_entry

    source · 
    fn set_kernel_trap_entry()
    \ No newline at end of file diff --git a/ch5/os/trap/fn.set_user_trap_entry.html b/ch5/os/trap/fn.set_user_trap_entry.html index 9c6f8ff1..5b3f1ca9 100644 --- a/ch5/os/trap/fn.set_user_trap_entry.html +++ b/ch5/os/trap/fn.set_user_trap_entry.html @@ -1 +1 @@ -set_user_trap_entry in os::trap - Rust

    Function os::trap::set_user_trap_entry

    source · [−]
    fn set_user_trap_entry()
    \ No newline at end of file +set_user_trap_entry in os::trap - Rust

    Function os::trap::set_user_trap_entry

    source · 
    fn set_user_trap_entry()
    \ No newline at end of file diff --git a/ch5/os/trap/fn.trap_from_kernel.html b/ch5/os/trap/fn.trap_from_kernel.html index 0a605f3c..b53abc14 100644 --- a/ch5/os/trap/fn.trap_from_kernel.html +++ b/ch5/os/trap/fn.trap_from_kernel.html @@ -1,4 +1,4 @@ -trap_from_kernel in os::trap - Rust

    Function os::trap::trap_from_kernel

    source · [−]
    #[no_mangle]
-pub fn trap_from_kernel() -> !
    Expand description

    Unimplement: traps/interrupts/exceptions from kernel mode +trap_from_kernel in os::trap - Rust

    Function os::trap::trap_from_kernel

    source · 
    #[no_mangle]
+pub fn trap_from_kernel() -> !
    Expand description

    Unimplement: traps/interrupts/exceptions from kernel mode Todo: Chapter 9: I/O device

    -
    \ No newline at end of file +
    \ No newline at end of file diff --git a/ch5/os/trap/fn.trap_handler.html b/ch5/os/trap/fn.trap_handler.html index a4784155..f05a5da7 100644 --- a/ch5/os/trap/fn.trap_handler.html +++ b/ch5/os/trap/fn.trap_handler.html @@ -1,3 +1,3 @@ -trap_handler in os::trap - Rust

    Function os::trap::trap_handler

    source · [−]
    #[no_mangle]
-pub fn trap_handler() -> !
    Expand description

    handle an interrupt, exception, or system call from user space

    -
    \ No newline at end of file +trap_handler in os::trap - Rust

    Function os::trap::trap_handler

    source · 
    #[no_mangle]
+pub fn trap_handler() -> !
    Expand description

    handle an interrupt, exception, or system call from user space

    +
    \ No newline at end of file diff --git a/ch5/os/trap/fn.trap_return.html b/ch5/os/trap/fn.trap_return.html index 79e65c6f..695a6ba0 100644 --- a/ch5/os/trap/fn.trap_return.html +++ b/ch5/os/trap/fn.trap_return.html @@ -1,5 +1,5 @@ -trap_return in os::trap - Rust

    Function os::trap::trap_return

    source · [−]
    #[no_mangle]
-pub fn trap_return() -> !
    Expand description

    set the new addr of __restore asm function in TRAMPOLINE page, +trap_return in os::trap - Rust

    Function os::trap::trap_return

    source · 
    #[no_mangle]
+pub fn trap_return() -> !
    Expand description

    set the new addr of __restore asm function in TRAMPOLINE page, set the reg a0 = trap_cx_ptr, reg a1 = phy addr of usr page table, finally, jump to new addr of __restore asm function

    -
    \ No newline at end of file +
    \ No newline at end of file diff --git a/ch5/os/trap/index.html b/ch5/os/trap/index.html index 3a27b318..859d7749 100644 --- a/ch5/os/trap/index.html +++ b/ch5/os/trap/index.html @@ -1,21 +1,14 @@ -os::trap - Rust

    Module os::trap

    source · [−]
    Expand description

    Trap handling functionality

    +os::trap - Rust

    Module os::trap

    source ·
    Expand description

    Trap handling functionality

    For rCore, we have a single trap entry point, namely __alltraps. At -initialization in init(), we set the stvec CSR to point to it.

    +initialization in init(), we set the stvec CSR to point to it.

    All traps go through __alltraps, which is defined in trap.S. The assembly language code does just enough work restore the kernel space context, ensuring that Rust code safely runs, and transfers control to -trap_handler().

    +trap_handler().

    It then calls different functionality based on what exactly the exception was. For example, timer interrupts trigger task preemption, and syscalls go -to syscall().

    -

    Modules

    context 🔒

    Implementation of TrapContext

    -

    Structs

    TrapContext

    trap context structure containing sstatus, sepc and registers

    -

    Functions

    enable_timer_interrupt

    enable timer interrupt in sie CSR

    -
    init

    initialize CSR stvec as the entry of __alltraps

    -
    set_kernel_trap_entry 🔒
    set_user_trap_entry 🔒
    trap_from_kernel

    Unimplement: traps/interrupts/exceptions from kernel mode -Todo: Chapter 9: I/O device

    -
    trap_handler

    handle an interrupt, exception, or system call from user space

    -
    trap_return

    set the new addr of __restore asm function in TRAMPOLINE page, +to syscall().

    +

    Modules

    Structs

    • TrapContext
      trap context structure containing sstatus, sepc and registers

    Functions

    • enable_timer_interrupt
      enable timer interrupt in sie CSR
    • init
      initialize CSR stvec as the entry of __alltraps
    • set_kernel_trap_entry 🔒
    • set_user_trap_entry 🔒
    • trap_from_kernel
      Unimplement: traps/interrupts/exceptions from kernel mode +Todo: Chapter 9: I/O device
    • trap_handler
      handle an interrupt, exception, or system call from user space
    • trap_return
      set the new addr of __restore asm function in TRAMPOLINE page, set the reg a0 = trap_cx_ptr, reg a1 = phy addr of usr page table, -finally, jump to new addr of __restore asm function

      -
    \ No newline at end of file +finally, jump to new addr of __restore asm function \ No newline at end of file diff --git a/ch5/os/trap/sidebar-items.js b/ch5/os/trap/sidebar-items.js index ba94a4d1..0901c834 100644 --- a/ch5/os/trap/sidebar-items.js +++ b/ch5/os/trap/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {"fn":[["enable_timer_interrupt","enable timer interrupt in sie CSR"],["init","initialize CSR `stvec` as the entry of `__alltraps`"],["set_kernel_trap_entry",""],["set_user_trap_entry",""],["trap_from_kernel","Unimplement: traps/interrupts/exceptions from kernel mode Todo: Chapter 9: I/O device"],["trap_handler","handle an interrupt, exception, or system call from user space"],["trap_return","set the new addr of __restore asm function in TRAMPOLINE page, set the reg a0 = trap_cx_ptr, reg a1 = phy addr of usr page table, finally, jump to new addr of __restore asm function"]],"mod":[["context","Implementation of [`TrapContext`]"]],"struct":[["TrapContext","trap context structure containing sstatus, sepc and registers"]]}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"fn":["enable_timer_interrupt","init","set_kernel_trap_entry","set_user_trap_entry","trap_from_kernel","trap_handler","trap_return"],"mod":["context"],"struct":["TrapContext"]}; \ No newline at end of file diff --git a/ch5/os/trap/struct.TrapContext.html b/ch5/os/trap/struct.TrapContext.html index 649c8954..a30893a7 100644 --- a/ch5/os/trap/struct.TrapContext.html +++ b/ch5/os/trap/struct.TrapContext.html @@ -1,28 +1,33 @@ -TrapContext in os::trap - Rust

    Struct os::trap::TrapContext

    source · [−]
    #[repr(C)]
    pub struct TrapContext {
-    pub x: [usize; 32],
+TrapContext in os::trap - Rust
    Struct os::trap::TrapContext
    source · 
    #[repr(C)]
    pub struct TrapContext {
+    pub x: [usize; 32],
     pub sstatus: Sstatus,
     pub sepc: usize,
     pub kernel_satp: usize,
     pub kernel_sp: usize,
     pub trap_handler: usize,
-}
    Expand description
    trap context structure containing sstatus, sepc and registers
    
-
    Fields
    x: [usize; 32]
    general regs[0..31]
    
-
    sstatus: Sstatus
    CSR sstatus      
    
-
    sepc: usize
    CSR sepc
    
-
    kernel_satp: usize
    Addr of Page Table
    
-
    kernel_sp: usize
    kernel stack
    
-
    trap_handler: usize
    Addr of trap_handler function
    
-
    Implementations
    set stack pointer to x_2 reg (sp)
    
-
    init app context
    
-
    Auto Trait Implementations
    Blanket Implementations
    Gets the TypeId of self. Read more
    
-
    Immutably borrows from an owned value. Read more
    
-
    Mutably borrows from an owned value. Read more
    
-
    Returns the argument unchanged.
    
-
    Calls U::from(self).
    
+}
    Expand description

    trap context structure containing sstatus, sepc and registers

    +

    Fields§

    §x: [usize; 32]

    general regs[0..31]

    +
    §sstatus: Sstatus

    CSR sstatus

    +
    §sepc: usize

    CSR sepc

    +
    §kernel_satp: usize

    Addr of Page Table

    +
    §kernel_sp: usize

    kernel stack

    +
    §trap_handler: usize

    Addr of trap_handler function

    +

    Implementations§

    source§

    impl TrapContext

    source

    pub fn set_sp(&mut self, sp: usize)

    set stack pointer to x_2 reg (sp)

    +
    source

    pub fn app_init_context( + entry: usize, + sp: usize, + kernel_satp: usize, + kernel_sp: usize, + trap_handler: usize +) -> Self

    init app context

    +

    Auto Trait Implementations§

    Blanket Implementations§

    source§

    impl<T> Any for Twhere + T: 'static + ?Sized,

    source§

    fn type_id(&self) -> TypeId

    Gets the TypeId of self. Read more
    source§

    impl<T> Borrow<T> for Twhere + T: ?Sized,

    source§

    fn borrow(&self) -> &T

    Immutably borrows from an owned value. Read more
    source§

    impl<T> BorrowMut<T> for Twhere + T: ?Sized,

    source§

    fn borrow_mut(&mut self) -> &mut T

    Mutably borrows from an owned value. Read more
    source§

    impl<T> From<T> for T

    source§

    fn from(t: T) -> T

    Returns the argument unchanged.

    +
    source§

    impl<T, U> Into<U> for Twhere + U: From<T>,

    source§

    fn into(self) -> U

    Calls U::from(self).

    That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -

    The type returned in the event of a conversion error.

    -

    Performs the conversion.

    -
    \ No newline at end of file +From<T> for U chooses to do.

    +
    source§

    impl<T, U> TryFrom<U> for Twhere + U: Into<T>,

    §

    type Error = Infallible

    The type returned in the event of a conversion error.
    source§

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

    Performs the conversion.
    source§

    impl<T, U> TryInto<U> for Twhere + U: TryFrom<T>,

    §

    type Error = <U as TryFrom<T>>::Error

    The type returned in the event of a conversion error.
    source§

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

    Performs the conversion.
    \ No newline at end of file diff --git a/ch5/rustdoc.css b/ch5/rustdoc.css deleted file mode 100644 index 2e22b4cf..00000000 --- a/ch5/rustdoc.css +++ /dev/null @@ -1 +0,0 @@ - @font-face {font-family:'Fira Sans';font-style:normal;font-weight:400;src:local('Fira Sans'),url("FiraSans-Regular.woff2") format("woff2");font-display:swap;}@font-face {font-family:'Fira Sans';font-style:normal;font-weight:500;src:local('Fira Sans Medium'),url("FiraSans-Medium.woff2") format("woff2");font-display:swap;}@font-face {font-family:'Source Serif 4';font-style:normal;font-weight:400;src:local('Source Serif 4'),url("SourceSerif4-Regular.ttf.woff2") format("woff2");font-display:swap;}@font-face {font-family:'Source Serif 4';font-style:italic;font-weight:400;src:local('Source Serif 4 Italic'),url("SourceSerif4-It.ttf.woff2") format("woff2");font-display:swap;}@font-face {font-family:'Source Serif 4';font-style:normal;font-weight:700;src:local('Source Serif 4 Bold'),url("SourceSerif4-Bold.ttf.woff2") format("woff2");font-display:swap;}@font-face {font-family:'Source Code Pro';font-style:normal;font-weight:400;src:url("SourceCodePro-Regular.ttf.woff2") format("woff2");font-display:swap;}@font-face {font-family:'Source Code Pro';font-style:italic;font-weight:400;src:url("SourceCodePro-It.ttf.woff2") format("woff2");font-display:swap;}@font-face {font-family:'Source Code Pro';font-style:normal;font-weight:600;src:url("SourceCodePro-Semibold.ttf.woff2") format("woff2");font-display:swap;}@font-face {font-family:'NanumBarunGothic';src:url("NanumBarunGothic.ttf.woff2") format("woff2");font-display:swap;unicode-range:U+AC00-D7AF,U+1100-11FF,U+3130-318F,U+A960-A97F,U+D7B0-D7FF;}*{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;}html{content:"";}@media (prefers-color-scheme:light){html{content:"light";}}@media (prefers-color-scheme:dark){html{content:"dark";}}body{font:1rem/1.5 "Source Serif 4",NanumBarunGothic,serif;margin:0;position:relative;overflow-wrap:break-word;overflow-wrap:anywhere;-webkit-font-feature-settings:"kern","liga";-moz-font-feature-settings:"kern","liga";font-feature-settings:"kern","liga";background-color:var(--main-background-color);color:var(--main-color);}h1{font-size:1.5rem;}h2{font-size:1.375rem;}h3{font-size:1.25rem;}h1,h2,h3,h4,h5,h6{font-weight:500;}h1,h2,h3,h4{margin:20px 0 15px 0;padding-bottom:6px;}.docblock h3,.docblock h4,h5,h6{margin:15px 0 5px 0;}h1.fqn{margin:0;padding:0;border-bottom-color:var(--headings-border-bottom-color);}h2,h3,h4{border-bottom-color:var(--headings-border-bottom-color);}.main-heading{display:flex;flex-wrap:wrap;justify-content:space-between;padding-bottom:6px;margin-bottom:15px;}.main-heading a:hover{text-decoration:underline;}#toggle-all-docs{text-decoration:none;}h2,.top-doc .docblock>h3,.top-doc .docblock>h4{border-bottom:1px solid var(--headings-border-bottom-color);}h3.code-header{font-size:1.125rem;}h4.code-header{font-size:1rem;}.code-header{font-weight:600;border-bottom-style:none;margin:0;padding:0;margin-top:0.6em;margin-bottom:0.4em;}.impl,.impl-items .method,.methods .method,.impl-items .type,.methods .type,.impl-items .associatedconstant,.methods .associatedconstant,.impl-items .associatedtype,.methods .associatedtype{flex-basis:100%;font-weight:600;position:relative;}div.impl-items>div{padding-left:0;}h1,h2,h3,h4,h5,h6,.sidebar,.mobile-topbar,a.source,.search-input,.search-results .result-name,.content table td:first-child>a,.item-left>a,.out-of-band,span.since,#source-sidebar,#sidebar-toggle,details.rustdoc-toggle>summary::before,div.impl-items>div:not(.docblock):not(.item-info),.content ul.crate a.crate,a.srclink,#main-content>.since,#help-button>button,details.rustdoc-toggle.top-doc>summary,details.rustdoc-toggle.top-doc>summary::before,details.rustdoc-toggle.non-exhaustive>summary,details.rustdoc-toggle.non-exhaustive>summary::before,.scraped-example-title,.more-examples-toggle summary,.more-examples-toggle .hide-more,.example-links a,#main-content>ul.docblock>li>a{font-family:"Fira Sans",Arial,NanumBarunGothic,sans-serif;}h1,h2,h3,h4,a#toggle-all-docs,a.anchor,.small-section-header a,#source-sidebar a,pre.rust a,.sidebar h2 a,.sidebar h3 a,.mobile-topbar h2 a,.in-band a,.search-results a,.module-item .stab,.import-item .stab,.result-name .primitive>i,.result-name .keyword>i,.content .method .where,.content .fn .where,.content .where.fmt-newline{color:var(--main-color);}ol,ul{padding-left:24px;}ul ul,ol ul,ul ol,ol ol{margin-bottom:.625em;}p{margin:0 0 .75em 0;}summary{outline:none;}td,th{padding:0;}table{border-collapse:collapse;}button,input,optgroup,select,textarea{color:inherit;font:inherit;margin:0;}button{padding:1px 6px;}.rustdoc{display:flex;flex-direction:row;flex-wrap:nowrap;}main{position:relative;flex-grow:1;padding:10px 15px 40px 45px;min-width:0;}.source main{padding:15px;}.width-limiter{max-width:960px;margin-right:auto;}.source .width-limiter{max-width:unset;}details:not(.rustdoc-toggle) summary{margin-bottom:.6em;}code,pre,a.test-arrow,.code-header{font-family:"Source Code Pro",monospace;}.docblock code,.docblock-short code{border-radius:3px;padding:0 0.125em;}.docblock pre code,.docblock-short pre code{padding:0;}pre{padding:14px;}.docblock.item-decl{margin-left:0;}.item-decl pre{overflow-x:auto;}.source .content pre{padding:20px;}img{max-width:100%;}li{position:relative;}.source .content{max-width:none;overflow:visible;margin-left:0px;}nav.sub{position:relative;font-size:1rem;}.sub-container{display:flex;flex-direction:row;flex-wrap:nowrap;}.sub-logo-container{display:none;margin-right:20px;}.source .sub-logo-container{display:block;}.source .sub-logo-container>img{height:60px;width:60px;object-fit:contain;}.sidebar,.mobile-topbar,.sidebar-menu-toggle{background-color:var(--sidebar-background-color);}.sidebar{font-size:0.875rem;width:250px;min-width:200px;overflow-y:scroll;position:sticky;height:100vh;top:0;left:0;}.sidebar-elems,.sidebar>.location{padding-left:24px;}.sidebar .location{overflow-wrap:anywhere;}.rustdoc.source .sidebar{width:50px;min-width:0px;max-width:300px;flex-grow:0;flex-shrink:0;flex-basis:auto;border-right:1px solid;overflow-x:hidden;overflow-y:hidden;}.rustdoc.source .sidebar .sidebar-logo{display:none;}.source .sidebar,#sidebar-toggle,#source-sidebar{background-color:var(--sidebar-background-color);}#sidebar-toggle>button:hover,#sidebar-toggle>button:focus{background-color:var(--sidebar-background-color-hover);}.source .sidebar>*:not(#sidebar-toggle){opacity:0;visibility:hidden;}.source-sidebar-expanded .source .sidebar{overflow-y:auto;}.source-sidebar-expanded .source .sidebar>*:not(#sidebar-toggle){opacity:1;visibility:visible;}#all-types{margin-top:1em;}*{scrollbar-width:initial;scrollbar-color:var(--scrollbar-color);}.sidebar{scrollbar-width:thin;scrollbar-color:var(--scrollbar-color);}::-webkit-scrollbar{width:12px;}.sidebar::-webkit-scrollbar{width:8px;}::-webkit-scrollbar-track{-webkit-box-shadow:inset 0;background-color:var(--scrollbar-track-background-color);}.sidebar::-webkit-scrollbar-track{background-color:var(--scrollbar-track-background-color);}::-webkit-scrollbar-thumb,.sidebar::-webkit-scrollbar-thumb{background-color:var(--scrollbar-thumb-background-color);}.hidden{display:none !important;}.sidebar .logo-container{display:flex;margin-top:10px;margin-bottom:10px;justify-content:center;}.version{overflow-wrap:break-word;}.logo-container>img{height:100px;width:100px;}.location:empty{border:none;}.location a:first-of-type{font-weight:500;}.block{padding:0;}.block ul,.block li{padding:0;margin:0;list-style:none;}.block a,h2.location a{display:block;padding:0.25rem;margin-left:-0.25rem;text-overflow:ellipsis;overflow:hidden;}.sidebar h2{border-bottom:none;font-weight:500;padding:0;margin:0;margin-top:0.7rem;margin-bottom:0.7rem;}.sidebar h3{font-size:1.125rem;font-weight:500;padding:0;margin:0;}.sidebar-elems .block{margin-bottom:2em;}.sidebar-elems .block li a{white-space:nowrap;}.mobile-topbar{display:none;}.source .content pre.rust{white-space:pre;overflow:auto;padding-left:0;}.rustdoc .example-wrap{display:inline-flex;margin-bottom:10px;}.example-wrap{position:relative;width:100%;}.example-wrap>pre.line-number{overflow:initial;border:1px solid;padding:13px 8px;text-align:right;border-top-left-radius:5px;border-bottom-left-radius:5px;}.example-wrap>pre.rust a:hover{text-decoration:underline;}.line-numbers{text-align:right;}.rustdoc:not(.source) .example-wrap>pre:not(.line-number){width:100%;overflow-x:auto;}.rustdoc:not(.source) .example-wrap>pre.line-numbers{width:auto;overflow-x:visible;}.rustdoc .example-wrap>pre{margin:0;}#search{position:relative;}.search-loading{text-align:center;}#results>table{width:100%;table-layout:fixed;}.content>.example-wrap pre.line-numbers{position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;}.line-numbers span{cursor:pointer;}.docblock-short{overflow-wrap:break-word;overflow-wrap:anywhere;}.docblock-short p{display:inline;}.docblock-short p{overflow:hidden;text-overflow:ellipsis;margin:0;}.docblock>:not(pre)>code,.docblock-short>:not(pre)>code{white-space:pre-wrap;}.top-doc .docblock h2{font-size:1.375rem;}.top-doc .docblock h3{font-size:1.25rem;}.top-doc .docblock h4,.top-doc .docblock h5{font-size:1.125rem;}.top-doc .docblock h6{font-size:1rem;}.docblock h5{font-size:1rem;}.docblock h6{font-size:0.875rem;}.docblock h1,.docblock h2,.docblock h3,.docblock h4,.docblock h5,.docblock h6{border-bottom-color:var(--headings-border-bottom-color);}.docblock{margin-left:24px;position:relative;}.docblock>:not(.information):not(.more-examples-toggle){max-width:100%;overflow-x:auto;}.content .out-of-band{flex-grow:0;font-size:1.125rem;font-weight:normal;float:right;}.method>.code-header,.trait-impl>.code-header{max-width:calc(100% - 41px);display:block;}.content .in-band{flex-grow:1;margin:0px;padding:0px;overflow-wrap:break-word;overflow-wrap:anywhere;}.in-band>code,.in-band>.code-header{display:inline-block;}.docblock code,.docblock-short code,pre,.rustdoc.source .example-wrap{background-color:var(--code-block-background-color);}#main-content{position:relative;}#main-content>.since{top:inherit;}.content table:not(.table-display){border-spacing:0 5px;}.content td{vertical-align:top;}.content td:first-child{padding-right:20px;}.content td p:first-child{margin-top:0;}.content td h1,.content td h2{margin-left:0;font-size:1.125rem;}.content tr:first-child td{border-top:0;}.docblock table{margin:.5em 0;width:calc(100% - 2px);overflow-x:auto;display:block;}.docblock table td{padding:.5em;border:1px dashed;}.docblock table th{padding:.5em;text-align:left;border:1px solid;}.fields+table{margin-bottom:1em;}.content .item-list{list-style-type:none;padding:0;}.content .multi-column{-moz-column-count:5;-moz-column-gap:2.5em;-webkit-column-count:5;-webkit-column-gap:2.5em;column-count:5;column-gap:2.5em;}.content .multi-column li{width:100%;display:inline-block;}.content>.methods>.method{font-size:1rem;position:relative;}.content .method .where,.content .fn .where,.content .where.fmt-newline{display:block;font-size:0.875rem;}.content .methods>div:not(.notable-traits):not(.method){margin-left:40px;margin-bottom:15px;}.content .docblock>.impl-items{margin-left:20px;margin-top:-34px;}.content .docblock>.impl-items .table-display{margin:0;}.content .docblock>.impl-items table td{padding:0;}.content .docblock>.impl-items .table-display,.impl-items table td{border:none;}.item-info{display:block;}.content .item-info code{font-size:0.875rem;}.content .item-info{position:relative;margin-left:24px;}.sub-variant>div>.item-info{margin-top:initial;}.content .impl-items .docblock,.content .impl-items .item-info{margin-bottom:.6em;}.content .impl-items>.item-info{margin-left:40px;}.methods>.item-info,.content .impl-items>.item-info{margin-top:-8px;}.impl-items{flex-basis:100%;}#main-content>.item-info{margin-top:0;margin-left:0;}nav.sub{flex-grow:1;margin-bottom:25px;}.source nav.sub{margin-left:32px;}nav.main{padding:20px 0;text-align:center;}nav.main .current{border-top:1px solid;border-bottom:1px solid;}nav.main .separator{border:1px solid;display:inline-block;height:23px;margin:0 20px;}nav.sum{text-align:right;}nav.sub form{display:inline;}a{text-decoration:none;background:transparent;}.small-section-header{display:flex;justify-content:space-between;position:relative;}.small-section-header:hover>.anchor{display:initial;}.in-band:hover>.anchor,.impl:hover>.anchor,.method.trait-impl:hover>.anchor,.type.trait-impl:hover>.anchor,.associatedconstant.trait-impl:hover>.anchor,.associatedtype.trait-impl:hover>.anchor{display:inline-block;position:absolute;}.anchor{display:none;position:absolute;left:-0.5em;background:none !important;}.anchor.field{left:-5px;}.small-section-header>.anchor{left:-15px;padding-right:8px;}h2.small-section-header>.anchor{padding-right:6px;}.anchor::before{content:'§';}.docblock a:not(.srclink):not(.test-arrow):not(.scrape-help):hover,.docblock-short a:not(.srclink):not(.test-arrow):not(.scrape-help):hover,.item-info a{text-decoration:underline;}.block a.current.crate{font-weight:500;}table,.item-table{overflow-wrap:break-word;}.item-table{display:table;}.item-row{display:table-row;}.item-left,.item-right{display:table-cell;}.item-left{padding-right:1.25rem;}.search-container{position:relative;display:flex;height:34px;}.search-container>*{height:100%;}.search-results-title{display:inline;}#search-settings{font-size:1.5rem;font-weight:500;margin-bottom:20px;}#crate-search{min-width:115px;margin-top:5px;padding-left:0.15em;padding-right:23px;border:1px solid;border-radius:4px;outline:none;cursor:pointer;-moz-appearance:none;-webkit-appearance:none;background-repeat:no-repeat;background-color:transparent;background-size:20px;background-position:calc(100% - 1px) 56%;background-image:url("down-arrow.svg");max-width:100%;text-overflow:ellipsis;}.search-container{margin-top:4px;}.search-input{-webkit-appearance:none;-moz-box-sizing:border-box !important;box-sizing:border-box !important;outline:none;border:1px solid;border-radius:2px;padding:8px;font-size:1rem;width:100%;}.search-results{display:none;padding-bottom:2em;}.search-results.active{display:block;clear:both;}.search-results .desc>span{white-space:nowrap;text-overflow:ellipsis;overflow:hidden;display:block;}.search-results>a{display:block;width:100%;margin-left:2px;margin-right:2px;border-bottom:1px solid #aaa3;}.search-results>a>div{display:flex;flex-flow:row wrap;}.search-results .result-name,.search-results div.desc,.search-results .result-description{width:50%;}.search-results .result-name{padding-right:1em;}.search-results .result-name>span{display:inline-block;margin:0;font-weight:normal;}.popover{font-size:1rem;position:absolute;right:0;z-index:2;display:block;margin-top:7px;border-radius:3px;border:1px solid;font-size:1rem;}.popover::before{content:'';position:absolute;right:11px;border:solid;border-width:1px 1px 0 0;display:inline-block;padding:4px;transform:rotate(-45deg);top:-5px;}.popover,.popover::before{background-color:var(--main-background-color);color:var(--main-color);}#help-button .popover{max-width:600px;}#help-button .popover::before{right:48px;}#help-button dt{float:left;clear:left;display:block;margin-right:0.5rem;}#help-button span.top,#help-button span.bottom{text-align:center;display:block;font-size:1.125rem;}#help-button span.top{text-align:center;display:block;margin:10px 0;border-bottom:1px solid;padding-bottom:4px;margin-bottom:6px;}#help-button span.bottom{clear:both;border-top:1px solid;}.side-by-side{text-align:initial;}.side-by-side>div{width:50%;float:left;padding:0 20px 20px 17px;}.item-info .stab{width:fit-content;min-height:36px;display:flex;align-items:center;white-space:pre-wrap;}.stab{padding:3px;margin-bottom:5px;font-size:0.875rem;font-weight:normal;}.stab p{display:inline;margin:0;}.stab .emoji{font-size:1.25rem;}.emoji{text-shadow:1px 0 0 black,-1px 0 0 black,0 1px 0 black,0 -1px 0 black;}.module-item .stab,.import-item .stab{border-radius:3px;display:inline-block;font-size:0.875rem;line-height:1.2;margin-bottom:0;margin-left:0.3125em;padding:2px;vertical-align:text-bottom;}.module-item.unstable,.import-item.unstable{opacity:0.65;}.since{font-weight:normal;font-size:initial;}.rightside{padding-left:12px;padding-right:2px;position:initial;}.impl-items .srclink,.impl .srclink,.methods .srclink{font-weight:normal;font-size:1rem;}.rightside{float:right;}.variants_table{width:100%;}.variants_table tbody tr td:first-child{width:1%;}td.summary-column{width:100%;}.summary{padding-right:0px;}pre.rust .question-mark{font-weight:bold;}a.test-arrow{display:inline-block;visibility:hidden;position:absolute;padding:5px 10px 5px 10px;border-radius:5px;font-size:1.375rem;top:5px;right:5px;z-index:1;}.example-wrap:hover .test-arrow{visibility:visible;}a.test-arrow:hover{text-decoration:none;}.code-attribute{font-weight:300;}.item-spacer{width:100%;height:12px;}.out-of-band>span.since{position:initial;font-size:1.25rem;}h3.variant{font-weight:600;font-size:1.125rem;margin-bottom:10px;border-bottom:none;}.sub-variant h4{font-size:1rem;font-weight:400;border-bottom:none;margin-top:0;margin-bottom:0;}.sub-variant{margin-left:24px;margin-bottom:40px;}.sub-variant>.sub-variant-field{margin-left:24px;}.toggle-label{display:inline-block;margin-left:4px;margin-top:3px;}:target>code,:target>.code-header{opacity:1;}:target{padding-right:3px;}.information{position:absolute;left:-25px;margin-top:7px;z-index:1;}.tooltip{position:relative;display:inline-block;cursor:pointer;}.tooltip::after{display:none;text-align:center;padding:5px 3px 3px 3px;border-radius:6px;margin-left:5px;font-size:1rem;}.tooltip.ignore::after{content:"This example is not tested";}.tooltip.compile_fail::after{content:"This example deliberately fails to compile";}.tooltip.should_panic::after{content:"This example panics";}.tooltip.edition::after{content:"This code runs with edition " attr(data-edition);}.tooltip::before{content:" ";position:absolute;top:50%;left:16px;margin-top:-5px;border-width:5px;border-style:solid;display:none;}.tooltip:hover::before,.tooltip:hover::after{display:inline;}.tooltip.compile_fail,.tooltip.should_panic,.tooltip.ignore{font-weight:bold;font-size:1.25rem;}.notable-traits-tooltip{display:inline-block;cursor:pointer;}.notable-traits:hover .notable-traits-tooltiptext,.notable-traits .notable-traits-tooltiptext.force-tooltip{display:inline-block;}.notable-traits .notable-traits-tooltiptext{display:none;padding:5px 3px 3px 3px;border-radius:6px;margin-left:5px;z-index:10;font-size:1rem;cursor:default;position:absolute;border:1px solid;}.notable-traits-tooltip::after{content:"\00a0\00a0\00a0";}.notable-traits .notable,.notable-traits .docblock{margin:0;}.notable-traits .notable{margin:0;margin-bottom:13px;font-size:1.1875rem;font-weight:600;display:block;}.notable-traits .docblock code.content{margin:0;padding:0;font-size:1.25rem;}pre.rust.rust-example-rendered{position:relative;}pre.rust{tab-size:4;-moz-tab-size:4;}.search-failed{text-align:center;margin-top:20px;display:none;}.search-failed.active{display:block;}.search-failed>ul{text-align:left;max-width:570px;margin-left:auto;margin-right:auto;}#titles{height:35px;}#titles>button{float:left;width:33.3%;text-align:center;font-size:1.125rem;cursor:pointer;border:0;border-top:2px solid;}#titles>button:first-child:last-child{margin-right:1px;width:calc(100% - 1px);}#titles>button:not(:last-child){margin-right:1px;width:calc(33.3% - 1px);}#titles>button>div.count{display:inline-block;font-size:1rem;}.notable-traits{cursor:pointer;z-index:2;margin-left:5px;}#sidebar-toggle{position:sticky;top:0;left:0;font-weight:bold;font-size:1.25rem;border-bottom:1px solid;display:flex;height:40px;justify-content:center;align-items:center;z-index:10;}#source-sidebar{width:100%;z-index:1;overflow:auto;}#source-sidebar>.title{font-size:1.5rem;text-align:center;border-bottom:1px solid;margin-bottom:6px;}#sidebar-toggle>button{background:none;color:inherit;cursor:pointer;text-align:center;border:none;outline:none;position:absolute;top:0;bottom:0;left:0;right:0;width:100%;-webkit-appearance:none;opacity:1;}#settings-menu,#help-button{margin-left:4px;outline:none;}#copy-path{height:34px;}#settings-menu>a,#help-button>button,#copy-path{padding:5px;width:33px;border:1px solid;border-radius:2px;cursor:pointer;}#settings-menu{padding:0;}#settings-menu>a,#help-button>button{padding:5px;height:100%;display:block;}@keyframes rotating{from{transform:rotate(0deg);}to{transform:rotate(360deg);}}#settings-menu.rotate>a img{animation:rotating 2s linear infinite;}.setting-line .radio-line input:checked{box-shadow:inset 0 0 0 3px var(--main-background-color);background-color:var(--settings-input-color);}.setting-line .radio-line input:focus{box-shadow:0 0 1px 1px var(--settings-input-color);}.setting-line .radio-line input:checked:focus{box-shadow:inset 0 0 0 3px var(--main-background-color),0 0 2px 2px var(--settings-input-color);}.setting-line .radio-line input:hover{border-color:var(--settings-input-color) !important;}input:checked+.slider{background-color:var(--settings-input-color);}#help-button>button{text-align:center;font-size:20px;padding-top:2px;}#copy-path{background:initial;margin-left:10px;padding:0;padding-left:2px;border:0;}#theme-choices{display:none;position:absolute;left:0;top:28px;border:1px solid;border-radius:3px;z-index:1;cursor:pointer;}#theme-choices>button{border:none;width:100%;padding:4px 8px;text-align:center;background:rgba(0,0,0,0);overflow-wrap:normal;}#theme-choices>button:not(:first-child){border-top:1px solid;}kbd{display:inline-block;padding:3px 5px;font:15px monospace;line-height:10px;vertical-align:middle;border:solid 1px;border-radius:3px;cursor:default;}.hidden-by-impl-hider,.hidden-by-usual-hider{display:none !important;}#implementations-list>h3>span.in-band{width:100%;}.table-display{width:100%;border:0;border-collapse:collapse;border-spacing:0;font-size:1rem;}.table-display tr td:first-child{padding-right:0;}.table-display tr td:last-child{float:right;}.table-display .out-of-band{position:relative;font-size:1.125rem;display:block;}.table-display td:hover .anchor{display:block;top:2px;left:-5px;}#main-content>ul{padding-left:10px;}#main-content>ul>li{list-style:none;}.non-exhaustive{margin-bottom:1em;}details.dir-entry{padding-left:4px;}details.dir-entry>summary{margin:0 0 0 13px;list-style-position:outside;cursor:pointer;}details.dir-entry div.folders,details.dir-entry div.files{padding-left:23px;}details.dir-entry a{display:block;}details.rustdoc-toggle>summary.hideme{cursor:pointer;}details.rustdoc-toggle>summary{list-style:none;}details.rustdoc-toggle>summary::-webkit-details-marker,details.rustdoc-toggle>summary::marker{display:none;}details.rustdoc-toggle>summary.hideme>span{margin-left:9px;}details.rustdoc-toggle>summary::before{content:"";cursor:pointer;width:16px;height:16px;background-repeat:no-repeat;background-position:top left;display:inline-block;vertical-align:middle;opacity:.5;}details.rustdoc-toggle>summary::after{content:"Expand";overflow:hidden;width:0;height:0;position:absolute;}details.rustdoc-toggle>summary.hideme::after{content:"";}details.rustdoc-toggle>summary:focus::before,details.rustdoc-toggle>summary:hover::before{opacity:1;}details.rustdoc-toggle.top-doc>summary,details.rustdoc-toggle.top-doc>summary::before,details.rustdoc-toggle.non-exhaustive>summary,details.rustdoc-toggle.non-exhaustive>summary::before{font-size:1rem;}details.non-exhaustive{margin-bottom:8px;}details.rustdoc-toggle>summary.hideme::before{position:relative;}details.rustdoc-toggle>summary:not(.hideme)::before{position:absolute;left:-24px;top:4px;}.impl-items>details.rustdoc-toggle>summary:not(.hideme)::before{position:absolute;left:-24px;}details.rustdoc-toggle[open] >summary.hideme{position:absolute;}details.rustdoc-toggle{position:relative;}details.rustdoc-toggle[open] >summary.hideme>span{display:none;}details.rustdoc-toggle[open] >summary::before,details.rustdoc-toggle[open] >summary.hideme::before{background-image:url("toggle-minus.svg");}details.rustdoc-toggle>summary::before{background-image:url("toggle-plus.svg");}details.rustdoc-toggle[open] >summary::before,details.rustdoc-toggle[open] >summary.hideme::before{width:16px;height:16px;background-repeat:no-repeat;background-position:top left;display:inline-block;content:"";}details.rustdoc-toggle[open] >summary::after,details.rustdoc-toggle[open] >summary.hideme::after{content:"Collapse";}.docblock summary>*{display:inline-block;}@media (min-width:701px){.docblock>.information:first-child>.tooltip{margin-top:16px;}.source-sidebar-expanded .source .sidebar+main .width-limiter .sub-logo-container.rust-logo{display:none;}.source-sidebar-expanded .source .sidebar{width:300px;}}@media (max-width:700px){*[id]{scroll-margin-top:45px;}.rustdoc{padding-top:0px;display:block;}main{padding-left:15px;padding-top:0px;}.rustdoc,.main-heading{flex-direction:column;}.content .out-of-band{text-align:left;margin-left:initial;padding:initial;}.content .out-of-band .since::before{content:"Since ";}#copy-path{display:none;}.sidebar .sidebar-logo,.sidebar .location{display:none;}.sidebar-elems{margin-top:1em;}.sidebar{position:fixed;top:45px;left:-1000px;margin-left:0;margin:0;padding:0;z-index:11;height:calc(100vh - 45px);}.source main,.rustdoc.source .sidebar{top:0;padding:0;height:100vh;border:0;}.sidebar.shown,.source-sidebar-expanded .source .sidebar,.sidebar:focus-within{left:0;}.rustdoc.source>.sidebar{position:fixed;margin:0;z-index:11;width:0;}.mobile-topbar .location a{padding:0;margin:0;}.mobile-topbar .location{border:none;padding:0;margin:auto 0.5em auto auto;text-overflow:ellipsis;overflow:hidden;white-space:nowrap;font-size:24px;}.mobile-topbar .logo-container{max-height:45px;}.mobile-topbar .logo-container>img{max-width:35px;max-height:35px;margin-left:20px;margin-top:5px;margin-bottom:5px;}.mobile-topbar{display:flex;flex-direction:row;position:sticky;z-index:10;font-size:2rem;height:45px;width:100%;left:0;top:0;}.source .mobile-topbar{display:none;}.sidebar-menu-toggle{width:45px;font-size:32px;border:none;}.sidebar-elems{background-color:var(--sidebar-background-color);}.source nav:not(.sidebar).sub{margin-left:32px;}.content{margin-left:0px;}.source .content{margin-top:10px;}#search{margin-left:0;padding:0;}.anchor{display:none !important;}.notable-traits{position:absolute;left:-22px;top:24px;}#titles>button>div.count{float:left;width:100%;}#titles{height:50px;}#sidebar-filler{position:fixed;left:45px;width:calc(100% - 45px);top:0;height:45px;z-index:-1;border-bottom:1px solid;}#main-content>details.rustdoc-toggle>summary::before,#main-content>div>details.rustdoc-toggle>summary::before{left:-11px;}#sidebar-toggle{position:fixed;left:1px;top:100px;width:30px;font-size:1.5rem;text-align:center;padding:0;z-index:10;border-top-right-radius:3px;border-bottom-right-radius:3px;cursor:pointer;font-weight:bold;border:1px solid;border-left:0;}.source-sidebar-expanded #sidebar-toggle{left:unset;top:unset;width:unset;border-top-right-radius:unset;border-bottom-right-radius:unset;position:sticky;border:0;border-bottom:1px solid;}#source-sidebar{z-index:11;}#main-content>.line-numbers{margin-top:0;}.notable-traits .notable-traits-tooltiptext{left:0;top:100%;}#help-button{display:none;}.item-table{display:block;}.item-row{display:flex;flex-flow:column wrap;}.item-left,.item-right{width:100%;}.search-results>a{border-bottom:1px solid #aaa9;padding:5px 0px;}.search-results .result-name,.search-results div.desc,.search-results .result-description{width:100%;}.search-results div.desc,.search-results .result-description,.item-right{padding-left:2em;}.source-sidebar-expanded .source .sidebar{max-width:100vw;width:100vw;}details.rustdoc-toggle:not(.top-doc)>summary{margin-left:10px;}.impl-items>details.rustdoc-toggle>summary:not(.hideme)::before,#main-content>details.rustdoc-toggle:not(.top-doc)>summary::before,#main-content>div>details.rustdoc-toggle>summary::before{left:-11px;}}@media print{nav.sidebar,nav.sub,.content .out-of-band,a.srclink,#copy-path,details.rustdoc-toggle[open] >summary::before,details.rustdoc-toggle>summary::before,details.rustdoc-toggle.top-doc>summary{display:none;}.docblock{margin-left:0;}main{padding:10px;}}@media (max-width:464px){#titles,#titles>button{height:73px;}#main-content>table:not(.table-display) td{word-break:break-word;width:50%;}#crate-search{border-radius:4px;}.docblock{margin-left:12px;}.docblock code{overflow-wrap:break-word;overflow-wrap:anywhere;}.sub-container{flex-direction:column;}.sub-logo-container{align-self:center;}.source .sub-logo-container>img{height:35px;width:35px;}#sidebar-toggle{top:10px;}.source-sidebar-expanded #sidebar-toggle{top:unset;}}.method-toggle summary,.implementors-toggle summary,.impl{margin-bottom:0.75em;}.method-toggle[open]{margin-bottom:2em;}.implementors-toggle[open]{margin-bottom:2em;}#trait-implementations-list .method-toggle,#synthetic-implementations-list .method-toggle,#blanket-implementations-list .method-toggle{margin-bottom:1em;}.scraped-example-list .scrape-help{margin-left:10px;padding:0 4px;font-weight:normal;font-size:12px;position:relative;bottom:1px;background:transparent;border-width:1px;border-style:solid;border-radius:50px;}.scraped-example .code-wrapper{position:relative;display:flex;flex-direction:row;flex-wrap:wrap;width:100%;}.scraped-example:not(.expanded) .code-wrapper{max-height:240px;}.scraped-example:not(.expanded) .code-wrapper pre{overflow-y:hidden;max-height:240px;padding-bottom:0;}.scraped-example:not(.expanded) .code-wrapper pre.line-numbers{overflow-x:hidden;}.scraped-example .code-wrapper .prev{position:absolute;top:0.25em;right:2.25em;z-index:100;cursor:pointer;}.scraped-example .code-wrapper .next{position:absolute;top:0.25em;right:1.25em;z-index:100;cursor:pointer;}.scraped-example .code-wrapper .expand{position:absolute;top:0.25em;right:0.25em;z-index:100;cursor:pointer;}.scraped-example:not(.expanded) .code-wrapper:before{content:" ";width:100%;height:5px;position:absolute;z-index:100;top:0;}.scraped-example:not(.expanded) .code-wrapper:after{content:" ";width:100%;height:5px;position:absolute;z-index:100;bottom:0;}.scraped-example .code-wrapper .line-numbers{margin:0;padding:14px 0;}.scraped-example .code-wrapper .line-numbers span{padding:0 14px;}.scraped-example .code-wrapper .example-wrap{flex:1;overflow-x:auto;overflow-y:hidden;margin-bottom:0;}.scraped-example:not(.expanded) .code-wrapper .example-wrap{overflow-x:hidden;}.scraped-example .code-wrapper .example-wrap pre.rust{overflow-x:inherit;width:inherit;overflow-y:hidden;}.more-examples-toggle{max-width:calc(100% + 25px);margin-top:10px;margin-left:-25px;}.more-examples-toggle .hide-more{margin-left:25px;margin-bottom:5px;cursor:pointer;}.more-scraped-examples{margin-left:5px;display:flex;flex-direction:row;}.more-scraped-examples-inner{width:calc(100% - 20px);}.toggle-line{align-self:stretch;margin-right:10px;margin-top:5px;padding:0 4px;cursor:pointer;}.toggle-line-inner{min-width:2px;height:100%;}.more-scraped-examples .scraped-example{margin-bottom:20px;}.more-scraped-examples .scraped-example:last-child{margin-bottom:0;}.example-links a{margin-top:20px;}.example-links ul{margin-bottom:0;} \ No newline at end of file diff --git a/ch5/search-index.js b/ch5/search-index.js index 6f6e112e..f9c8276c 100644 --- a/ch5/search-index.js +++ b/ch5/search-index.js @@ -1,5 +1,5 @@ var searchIndex = JSON.parse('{\ -"os":{"doc":"The main module and entrypoint","t":[0,5,0,0,0,0,0,14,14,5,0,0,0,0,0,0,17,17,17,2,17,17,2,2,17,17,17,17,17,3,11,11,11,11,5,11,11,11,11,5,3,12,11,11,11,11,5,5,5,11,5,11,11,11,12,12,12,12,3,3,3,3,3,3,3,3,3,12,0,12,12,12,5,0,0,5,0,0,12,12,5,5,5,5,12,12,12,12,17,17,3,3,3,3,8,17,6,17,3,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,11,11,11,11,11,11,11,11,11,11,11,11,11,12,10,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,8,6,3,3,12,10,11,11,11,11,11,11,11,12,10,11,11,11,12,11,5,5,5,11,11,11,11,5,11,11,11,10,11,11,12,12,11,11,11,11,11,11,11,11,11,7,7,5,5,5,13,13,3,3,3,4,3,18,18,18,18,12,11,11,12,11,11,11,11,11,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,11,11,5,5,5,11,11,11,5,5,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,11,12,11,11,11,11,11,12,11,11,11,5,11,11,5,5,11,5,5,5,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,18,18,18,3,3,3,18,18,18,18,18,11,11,11,11,11,11,12,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,11,11,11,11,11,11,11,11,11,11,5,5,5,11,11,11,11,11,11,11,11,11,11,11,11,5,5,5,5,3,12,0,3,11,11,11,11,12,11,11,11,11,11,17,17,17,17,17,17,17,17,17,0,0,5,17,17,5,5,5,5,5,5,5,5,5,12,17,3,3,3,3,3,3,3,12,5,5,11,11,0,12,12,5,5,5,11,5,5,11,12,11,0,0,12,5,0,12,12,12,5,12,5,12,5,0,5,0,11,11,11,3,11,11,11,11,11,12,12,12,11,11,11,11,3,3,12,11,5,11,11,11,11,11,11,5,11,11,11,11,11,12,11,11,11,11,11,11,12,3,3,3,3,12,11,11,11,11,11,11,11,11,11,12,11,11,11,11,11,11,11,11,11,11,11,11,11,5,11,11,12,5,11,12,11,11,11,11,11,11,11,11,11,11,11,11,3,3,12,11,11,11,11,11,12,5,5,5,11,11,11,11,12,11,11,11,5,5,11,5,11,11,11,11,11,11,5,13,13,3,3,4,13,12,11,11,11,11,11,11,12,11,11,11,11,12,11,11,11,11,11,11,11,11,12,11,11,11,11,11,12,12,11,12,12,12,12,11,12,11,11,11,11,11,11,11,11,11,17,17,5,5,5,3,0,5,5,12,12,12,5,5,12,5,5,12,5,12,3,11,11,11,11,11,12,12,12,11,12,12,11,11,11,12],"n":["board","clear_bss","config","console","lang_items","loader","mm","print","println","rust_main","sbi","sync","syscall","task","timer","trap","CLOCK_FREQ","MEMORY_END","MMIO","CLOCK_FREQ","KERNEL_HEAP_SIZE","KERNEL_STACK_SIZE","MEMORY_END","MMIO","PAGE_SIZE","PAGE_SIZE_BITS","TRAMPOLINE","TRAP_CONTEXT","USER_STACK_SIZE","Stdout","borrow","borrow_mut","from","into","print","try_from","try_into","type_id","write_str","panic","APP_NAMES","__private_field","borrow","borrow_mut","deref","from","get_app_data","get_app_data_by_name","get_num_app","into","list_apps","try_from","try_into","type_id","0","0","0","0","FrameTracker","KERNEL_SPACE","MapPermission","MemorySet","PageTableEntry","PhysAddr","PhysPageNum","VirtAddr","VirtPageNum","__private_field","address","areas","bits","bits","frame_alloc","frame_allocator","heap_allocator","init","memory_set","page_table","page_table","ppn","remap_test","translated_byte_buffer","translated_refmut","translated_str","0","0","0","0","PA_WIDTH_SV39","PPN_WIDTH_SV39","PhysAddr","PhysPageNum","SimpleRange","SimpleRangeIterator","StepByOne","VA_WIDTH_SV39","VPNRange","VPN_WIDTH_SV39","VirtAddr","VirtPageNum","aligned","aligned","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","ceil","ceil","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","cmp","cmp","cmp","current","end","eq","eq","eq","eq","floor","floor","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","from","from","get_bytes_array","get_end","get_mut","get_mut","get_pte_array","get_start","indexes","into","into","into","into","into","into","into_iter","into_iter","l","ne","ne","ne","ne","new","new","next","page_offset","page_offset","partial_cmp","partial_cmp","partial_cmp","partial_cmp","r","step","step","to_owned","to_owned","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","FRAME_ALLOCATOR","FrameAllocator","FrameAllocatorImpl","FrameTracker","StackFrameAllocator","__private_field","alloc","alloc","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","current","dealloc","dealloc","deref","drop","end","fmt","frame_alloc","frame_allocator_test","frame_dealloc","from","from","from","init","init_frame_allocator","into","into","into","new","new","new","ppn","recycled","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","HEAP_ALLOCATOR","HEAP_SPACE","handle_alloc_error","heap_test","init_heap","Framed","Identical","KERNEL_SPACE","MapArea","MapPermission","MapType","MemorySet","R","U","W","X","__private_field","activate","all","areas","bitand","bitand_assign","bitor","bitor_assign","bits","bits","bitxor","bitxor_assign","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","cmp","complement","contains","copy_data","data_frames","deref","difference","ebss","edata","ekernel","empty","eq","eq","erodata","etext","extend","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from_another","from_bits","from_bits_truncate","from_bits_unchecked","from_elf","from_existed_user","from_iter","hash","insert","insert_framed_area","intersection","intersects","into","into","into","into","into","is_all","is_empty","map","map_one","map_perm","map_trampoline","map_type","ne","new","new_bare","new_kernel","not","page_table","partial_cmp","push","recycle_data_pages","remap_test","remove","remove_area_with_start_vpn","sbss_with_stack","sdata","set","srodata","stext","strampoline","sub","sub_assign","symmetric_difference","to_owned","to_owned","toggle","token","translate","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","union","unmap","unmap_one","vpn_range","A","D","G","PTEFlags","PageTable","PageTableEntry","R","U","V","W","X","all","bitand","bitand_assign","bitor","bitor_assign","bits","bits","bits","bitxor","bitxor_assign","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","cmp","complement","contains","difference","empty","empty","eq","executable","extend","find_pte","find_pte_create","flags","fmt","fmt","fmt","fmt","fmt","frames","from","from","from","from_bits","from_bits_truncate","from_bits_unchecked","from_iter","from_token","hash","insert","intersection","intersects","into","into","into","is_all","is_empty","is_valid","map","ne","new","new","not","partial_cmp","ppn","readable","remove","root_ppn","set","sub","sub_assign","symmetric_difference","to_owned","to_owned","toggle","token","translate","translate_va","translated_byte_buffer","translated_refmut","translated_str","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","union","unmap","writable","console_getchar","console_putchar","set_timer","shutdown","UPSafeCell","inner","up","UPSafeCell","borrow","borrow_mut","exclusive_access","from","inner","into","new","try_from","try_into","type_id","SYSCALL_EXEC","SYSCALL_EXIT","SYSCALL_FORK","SYSCALL_GETPID","SYSCALL_GET_TIME","SYSCALL_READ","SYSCALL_WAITPID","SYSCALL_WRITE","SYSCALL_YIELD","fs","process","syscall","FD_STDIN","FD_STDOUT","sys_read","sys_write","sys_exec","sys_exit","sys_fork","sys_get_time","sys_getpid","sys_waitpid","sys_yield","0","IDLE_PID","INITPROC","KernelStack","PidAllocator","PidHandle","Processor","TaskContext","TaskManager","__private_field","add_initproc","add_task","borrow","borrow_mut","context","current","current","current_task","current_trap_cx","current_user_token","deref","exit_current_and_run_next","fetch_task","from","idle_task_cx","into","manager","pid","pid","pid_alloc","processor","ra","ready_queue","recycled","run_tasks","s","schedule","sp","suspend_current_and_run_next","switch","take_current_task","task","try_from","try_into","type_id","TaskContext","borrow","borrow_mut","from","goto_trap_return","into","ra","s","sp","try_from","try_into","type_id","zero_init","TASK_MANAGER","TaskManager","__private_field","add","add_task","borrow","borrow","borrow_mut","borrow_mut","deref","fetch","fetch_task","from","from","into","into","new","ready_queue","try_from","try_from","try_into","try_into","type_id","type_id","0","KernelStack","PID_ALLOCATOR","PidAllocator","PidHandle","__private_field","alloc","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","current","dealloc","deref","drop","drop","from","from","from","from","get_top","into","into","into","into","kernel_stack_position","new","new","pid","pid_alloc","push_on_top","recycled","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","PROCESSOR","Processor","__private_field","borrow","borrow","borrow_mut","borrow_mut","current","current","current_task","current_trap_cx","current_user_token","deref","from","from","get_idle_task_cx_ptr","idle_task_cx","into","into","new","run_tasks","schedule","take_current","take_current_task","try_from","try_from","try_into","try_into","type_id","type_id","__switch","Ready","Running","TaskControlBlock","TaskControlBlockInner","TaskStatus","Zombie","base_size","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","children","clone","clone_into","eq","exec","exit_code","fork","from","from","from","get_status","get_trap_cx","get_user_token","getpid","inner","inner_exclusive_access","into","into","into","is_zombie","kernel_stack","memory_set","new","parent","pid","task_cx","task_status","to_owned","trap_cx_ppn","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","MSEC_PER_SEC","TICKS_PER_SEC","get_time","get_time_ms","set_next_trigger","TrapContext","context","enable_timer_interrupt","init","kernel_satp","kernel_sp","sepc","set_kernel_trap_entry","set_user_trap_entry","sstatus","trap_from_kernel","trap_handler","trap_handler","trap_return","x","TrapContext","app_init_context","borrow","borrow_mut","from","into","kernel_satp","kernel_sp","sepc","set_sp","sstatus","trap_handler","try_from","try_into","type_id","x"],"q":["os","","","","","","","","","","","","","","","","os::board","","","os::config","","","","","","","","","","os::console","","","","","","","","","","os::lang_items","os::loader","","","","","","","","","","","","","","os::mm","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","os::mm::address","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","os::mm::frame_allocator","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","os::mm::heap_allocator","","","","","os::mm::memory_set","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","os::mm::page_table","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","os::sbi","","","","os::sync","","","os::sync::up","","","","","","","","","","","os::syscall","","","","","","","","","","","","os::syscall::fs","","","","os::syscall::process","","","","","","","os::task","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","os::task::context","","","","","","","","","","","","","os::task::manager","","","","","","","","","","","","","","","","","","","","","","","","os::task::pid","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","os::task::processor","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","os::task::switch","os::task::task","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","os::timer","","","","","os::trap","","","","","","","","","","","","","","","os::trap::context","","","","","","","","","","","","","","",""],"d":["Constants used in rCore for qemu","clear BSS segment","Constants used in rCore","SBI console driver, for text output","The panic handler","Loading user applications into memory","Memory management implementation","print string macro","println string macro","the rust entry-point of os","SBI call wrappers","Synchronization and interior mutability primitives","Implementation of syscalls","Task management implementation","RISC-V timer-related functionality","Trap handling functionality","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Calls U::from(self).","","","","","","","All of app’s name","","","","","Returns the argument unchanged.","get applications data","get app data from name","get app number","Calls U::from(self).","list all apps","","","","","","","","manage a frame which has the same lifecycle as the tracker","a memory set instance through lazy_static! managing kernel …","map permission corresponding to that in pte: R W X U","memory set structure, controls virtual-memory space","page table entry structure","physical address","physical page number","virtual address","virtual page number","","Implementation of physical and virtual address and page …","","","PTE","allocate a frame","Implementation of FrameAllocator which controls all the …","The global allocator","initiate heap allocator, frame allocator and kernel space","Implementation of MapArea and MemorySet.","Implementation of PageTableEntry and PageTable.","","","Check PageTable running correctly","translate a pointer to a mutable u8 Vec through page table","translate a generic through page table and return a …","translate a pointer to a mutable u8 Vec end with \\\\0 …","","","","","physical address","","physical address","physical page number","a simple range structure for type T","iterator for the simple range structure","","","a simple range structure for virtual page number","","virtual address","virtual page number","Check page aligned","Check page aligned","","","","","","","","","","","","","PhysAddr->PhysPageNum","VirtAddr->VirtPageNum","","","","","","","","","","","","","","","","","","","","","PhysAddr->PhysPageNum","VirtAddr->VirtPageNum","","","","","Returns the argument unchanged.","","","Returns the argument unchanged.","Returns the argument unchanged.","","","Returns the argument unchanged.","","","Returns the argument unchanged.","","","Returns the argument unchanged.","","","Get mutable reference to PhysAddr value","","Get PageTableEntry on PhysPageNum","","Return VPN 3 level index","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","","","","","","","","","","","Get page offset","Get page offset","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","frame allocator instance through lazy_static!","","","manage a frame which has the same lifecycle as the tracker","an implementation for frame allocator","","","","","","","","","","","","","","","","","allocate a frame","a simple test for frame allocator","deallocate a frame","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","initiate the frame allocator using ekernel and MEMORY_END","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","","Create an empty FrameTracker","","","","","","","","","","","","","heap allocator instance","heap space ([u8; KERNEL_HEAP_SIZE])","panic when heap allocation error occurs","","initiate heap allocator","","","a memory set instance through lazy_static! managing kernel …","map area structure, controls a contiguous piece of virtual …","map permission corresponding to that in pte: R W X U","map type for memory set: identical or framed","memory set structure, controls virtual-memory space","Readable","Accessible in U mode","Writable","Excutable","","Refresh TLB with sfence.vma","Returns the set containing all flags.","","Returns the intersection between the two sets of flags.","Disables all flags disabled in the set.","Returns the union of the two sets of flags.","Adds the set of flags.","Returns the raw value of the flags currently stored.","","Returns the left flags, but with all the right flags …","Toggles the set of flags.","","","","","","","","","","","","","","","","Returns the complement of this set of flags.","Returns true if all of the flags in other are contained …","data: start-aligned but maybe with shorter length assume …","","","Returns the difference between the flags in self and other.","","","","Returns an empty set of flags.","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","Convert from underlying bit representation, unless that …","Convert from underlying bit representation, dropping any …","Convert from underlying bit representation, preserving all …","Include sections in elf and trampoline and TrapContext and …","Clone a same MemorySet","","","Inserts the specified flags in-place.","Assume that no conflicts.","Returns the intersection between the flags in self and …","Returns true if there are flags common to both self and …","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Returns true if all flags are currently set.","Returns true if no flags are currently stored.","","","","Mention that trampoline is not collected by areas.","","","","Create an empty MemorySet","Without kernel stacks.","Returns the complement of this set of flags.","","","","Remove all MapArea","Check PageTable running correctly","Removes the specified flags in-place.","Remove MapArea that starts with start_vpn","","","Inserts or removes the specified flags depending on the …","","","","Returns the set difference of the two sets of flags.","Disables all flags enabled in the set.","Returns the symmetric difference between the flags in self …","","","Toggles the specified flags in-place.","Get pagetable root_ppn","Translate throuth pagetable","","","","","","","","","","","","","","","","Returns the union of between the flags in self and other.","","","","","","","","","page table entry structure","","","","","","Returns the set containing all flags.","Returns the intersection between the two sets of flags.","Disables all flags disabled in the set.","Returns the union of the two sets of flags.","Adds the set of flags.","Returns the raw value of the flags currently stored.","","PTE","Returns the left flags, but with all the right flags …","Toggles the set of flags.","","","","","","","","","","","","Returns the complement of this set of flags.","Returns true if all of the flags in other are contained …","Returns the difference between the flags in self and other.","Returns an empty set of flags.","Return an empty PTE","","Check PTE executable","","","","Return 10bit flag","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Convert from underlying bit representation, unless that …","Convert from underlying bit representation, dropping any …","Convert from underlying bit representation, preserving all …","","Temporarily used to get arguments from user space.","","Inserts the specified flags in-place.","Returns the intersection between the flags in self and …","Returns true if there are flags common to both self and …","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Returns true if all flags are currently set.","Returns true if no flags are currently stored.","Check PTE valid","","","","Create a PTE from ppn","Returns the complement of this set of flags.","","Return 44bit ppn","Check PTE readable","Removes the specified flags in-place.","","Inserts or removes the specified flags depending on the …","Returns the set difference of the two sets of flags.","Disables all flags enabled in the set.","Returns the symmetric difference between the flags in self …","","","Toggles the specified flags in-place.","","","","translate a pointer to a mutable u8 Vec through page table","translate a generic through page table and return a …","translate a pointer to a mutable u8 Vec end with \\\\0 …","","","","","","","","","","Returns the union of between the flags in self and other.","","Check PTE writable","use sbi call to getchar from console (qemu uart handler)","use sbi call to putchar in console (qemu uart handler)","use sbi call to set timer","use sbi call to shutdown the kernel","Wrap a static data structure inside it so that we are able …","inner data","Uniprocessor interior mutability primitives","Wrap a static data structure inside it so that we are able …","","","Exclusive access inner data in UPSafeCell. Panic if the …","Returns the argument unchanged.","inner data","Calls U::from(self).","User is responsible to guarantee that inner struct is only …","","","","","","","","","","","","","File and filesystem-related syscalls","","handle syscall exception with syscall_id and other …","","","","","","","","","","If there is not a child process whose pid is same as …","","","pid of usertests app in make run TEST=1","Globle process that init user shell","Kernelstack for app","Pid Allocator struct","Bind pid lifetime to PidHandle","Processor management structure","task context structure containing some registers","A array of TaskControlBlock that is thread-safe","","Add init process to the manager","Interface offered to add task","","","Implementation of TaskContext","","The task currently executing on the current processor","Get running task","Get the mutable reference to trap context of current task","Get token of the address space of current task","","Exit the current ‘Running’ task and run the next task …","Interface offered to pop the first task","Returns the argument unchanged.","The basic control flow of each core, helping to select and …","Calls U::from(self).","Implementation of TaskManager","Implementation of PidAllocator","","Allocate a pid from PID_ALLOCATOR","Implementation of Processor and Intersection of control …","return address ( e.g. __restore ) of __switch ASM function","","","The main part of process execution and scheduling Loop …","s0-11 register, callee saved","Return to idle control flow for new scheduling","kernel stack pointer of app","Suspend the current ‘Running’ task and run the next …","Wrap switch.S as a function","Take the current task,leaving a None in its place","Implementation of TaskControlBlock","","","","task context structure containing some registers","","","Returns the argument unchanged.","set Task Context{__restore ASM funciton: trap_return, sp: …","Calls U::from(self).","return address ( e.g. __restore ) of __switch ASM function","s0-11 register, callee saved","kernel stack pointer of app","","","","init task context","","A array of TaskControlBlock that is thread-safe","","Add a task to TaskManager","Interface offered to add task","","","","","","Remove the first task and return it,or None if TaskManager …","Interface offered to pop the first task","Returns the argument unchanged.","Returns the argument unchanged.","Calls U::from(self).","Calls U::from(self).","Creat an empty TaskManager","","","","","","","","","Kernelstack for app","","Pid Allocator struct","Bind pid lifetime to PidHandle","","Allocate a pid","","","","","","","","","","Recycle a pid","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Get the value on the top of kernelstack","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Return (bottom, top) of a kernel stack in kernel space.","Create an empty PidAllocator","Create a kernelstack from pid","","Allocate a pid from PID_ALLOCATOR","Push a value on top of kernelstack","","","","","","","","","","","","","","","Processor management structure","","","","","","Get current task in cloning semanteme","The task currently executing on the current processor","Get running task","Get the mutable reference to trap context of current task","Get token of the address space of current task","","Returns the argument unchanged.","Returns the argument unchanged.","Get mutable reference to idle_task_cx","The basic control flow of each core, helping to select and …","Calls U::from(self).","Calls U::from(self).","Create an empty Processor","The main part of process execution and scheduling Loop …","Return to idle control flow for new scheduling","Get current task in moving semanteme","Take the current task,leaving a None in its place","","","","","","","","","","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","","","","","","","","","","","","","","","","","","","","","","get current time","get current time in microseconds","set the next timer interrupt","trap context structure containing sstatus, sepc and …","Implementation of TrapContext","enable timer interrupt in sie CSR","initialize CSR stvec as the entry of __alltraps","Addr of Page Table","kernel stack","CSR sepc","","","CSR sstatus ","Unimplement: traps/interrupts/exceptions from kernel mode …","handle an interrupt, exception, or system call from user …","Addr of trap_handler function","set the new addr of __restore asm function in TRAMPOLINE …","general regs[0..31]","trap context structure containing sstatus, sepc and …","init app context","","","Returns the argument unchanged.","Calls U::from(self).","Addr of Page Table","kernel stack","CSR sepc","set stack pointer to x_2 reg (sp)","CSR sstatus ","Addr of trap_handler function","","","","general regs[0..31]"],"i":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,5,5,5,0,5,5,5,5,0,0,9,9,9,9,9,0,0,0,9,0,9,9,9,16,18,19,20,0,0,0,0,0,0,0,0,0,35,0,30,31,38,0,0,0,0,0,0,30,13,0,0,0,0,16,18,19,20,0,0,0,0,0,0,0,0,0,0,0,0,16,18,25,16,18,19,20,22,25,16,18,19,20,22,16,18,16,18,19,20,22,16,18,19,20,22,16,18,19,20,25,25,16,18,19,20,16,18,16,18,19,20,25,16,16,16,18,18,18,19,19,19,20,20,20,22,19,22,16,19,19,22,20,25,16,18,19,20,22,25,22,22,16,18,19,20,25,22,25,16,18,16,18,19,20,22,57,20,16,18,19,20,22,25,16,18,19,20,22,25,16,18,19,20,22,25,16,18,19,20,22,0,0,0,0,0,27,58,26,13,26,27,13,26,27,26,58,26,27,13,26,13,0,0,0,13,26,27,26,0,13,26,27,58,13,26,13,26,13,26,27,13,26,27,13,26,27,0,0,0,0,0,32,32,0,0,0,0,0,31,31,31,31,35,30,31,30,31,31,31,31,31,31,31,31,30,33,35,32,31,30,33,35,32,31,32,31,32,31,31,31,31,33,33,35,31,0,0,0,31,32,31,0,0,31,32,31,31,31,31,31,30,33,35,32,31,33,31,31,31,30,30,31,31,31,30,31,31,30,33,35,32,31,31,31,33,33,33,30,33,31,33,30,30,31,30,31,30,30,0,31,30,0,0,31,0,0,0,31,31,31,32,31,31,30,30,30,33,35,32,31,30,33,35,32,31,30,33,35,32,31,31,33,33,33,39,39,39,0,0,0,39,39,39,39,39,39,39,39,39,39,39,39,38,39,39,34,39,38,34,39,38,39,38,39,38,39,39,39,39,39,38,39,38,39,34,34,38,39,39,39,39,39,34,34,39,38,39,39,39,39,34,39,39,39,39,34,39,38,39,39,38,34,39,34,38,39,39,38,38,39,34,39,39,39,39,39,38,39,34,34,34,0,0,0,34,39,38,34,39,38,34,39,38,39,34,38,0,0,0,0,0,28,0,0,28,28,28,28,28,28,28,28,28,28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,46,0,0,0,0,0,0,0,0,45,0,0,45,45,0,50,53,0,0,0,45,0,0,45,53,45,0,0,52,0,0,47,48,50,0,47,0,47,0,0,0,0,45,45,45,0,47,47,47,47,47,47,47,47,47,47,47,47,0,0,49,48,0,48,49,48,49,49,48,0,48,49,48,49,48,48,48,49,48,49,48,49,46,0,0,0,0,51,50,50,46,52,51,50,46,52,51,50,50,51,46,52,50,46,52,51,52,50,46,52,51,0,50,52,52,0,52,50,50,46,52,51,50,46,52,51,50,46,52,51,0,0,54,53,54,53,54,53,53,0,0,0,54,53,54,53,53,53,54,53,0,0,53,0,53,54,53,54,53,54,0,55,55,0,0,0,55,56,43,56,55,43,56,55,56,55,55,55,43,56,43,43,56,55,56,56,56,43,43,43,43,56,55,56,43,56,43,56,43,56,56,55,56,43,56,55,43,56,55,43,56,55,0,0,0,0,0,0,0,0,0,44,44,44,0,0,44,0,0,44,0,44,0,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44],"f":[0,[[]],0,0,0,0,0,0,0,[[],1],0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,[[]],[[]],[[]],[[]],[2],[[],3],[[],3],[[],4],[[5,6],7],[8,1],0,0,[[]],[[]],[9,10],[[]],[11],[6,12],[[],11],[[]],[[]],[[],3],[[],3],[[],4],0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,[[],[[12,[13]]]],0,0,[[]],0,0,0,0,[[]],[[11,14,11],10],[11],[[11,14],15],0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,[16,17],[18,17],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[16,19],[18,20],[16,16],[18,18],[19,19],[20,20],[[[22,[21]]],[[22,[21]]]],[[]],[[]],[[]],[[]],[[]],[[16,16],23],[[18,18],23],[[19,19],23],[[20,20],23],0,0,[[16,16],17],[[18,18],17],[[19,19],17],[[20,20],17],[16,19],[18,20],[[16,24],7],[[18,24],7],[[19,24],7],[[20,24],7],[[]],[11,16],[19,16],[[]],[[]],[20,18],[11,18],[[]],[11,19],[16,19],[[]],[18,20],[11,20],[[]],[19],[22],[16],[19],[19],[22],[20],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[22],0,[[16,16],17],[[18,18],17],[[19,19],17],[[20,20],17],[[],25],[[],22],[25,12],[16,11],[18,11],[[16,16],[[12,[23]]]],[[18,18],[[12,[23]]]],[[19,19],[[12,[23]]]],[[20,20],[[12,[23]]]],0,[[]],[20],[[]],[[]],[[]],[[]],[[]],[[],3],[[],3],[[],3],[[],3],[[],3],[[],3],[[],3],[[],3],[[],3],[[],3],[[],3],[[],3],[[],4],[[],4],[[],4],[[],4],[[],4],[[],4],0,0,0,0,0,0,[[],[[12,[19]]]],[26,[[12,[19]]]],[[]],[[]],[[]],[[]],[[]],[[]],0,[19],[[26,19]],[27,28],[13],0,[[13,24],7],[[],[[12,[13]]]],[[]],[19],[[]],[[]],[[]],[[26,19,19]],[[]],[[]],[[]],[[]],[[]],[19,13],[[],26],0,0,[[],3],[[],3],[[],3],[[],3],[[],3],[[],3],[[],4],[[],4],[[],4],0,0,[29,1],[[]],[[]],0,0,0,0,0,0,0,0,0,0,0,0,[30],[[],31],0,[[31,31],31],[[31,31]],[[31,31],31],[[31,31]],[31,14],0,[[31,31],31],[[31,31]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[32,32],[31,31],[[]],[[]],[[31,31],23],[31,31],[[31,31],17],[[33,34]],0,[35,36],[[31,31],31],0,0,0,[[],31],[[32,32],17],[[31,31],17],0,0,[[31,37]],[[32,24],7],[[31,24],7],[[31,24],7],[[31,24],7],[[31,24],7],[[31,24],7],[[]],[[]],[[]],[[]],[[]],[33,33],[14,[[12,[31]]]],[14,31],[14,31],[[]],[30,30],[37,31],[31],[[31,31]],[[30,18,18,31]],[[31,31],31],[[31,31],17],[[]],[[]],[[]],[[]],[[]],[31,17],[31,17],[[33,34]],[[33,34,20]],0,[30],0,[[31,31],17],[[18,18,32,31],33],[[],30],[[],30],[31,31],0,[[31,31],[[12,[23]]]],[[30,33,12]],[30],[[]],[[31,31]],[[30,20]],0,0,[[31,31,17]],0,0,0,[[31,31],31],[[31,31]],[[31,31],31],[[]],[[]],[[31,31]],[30,11],[[30,20],[[12,[38]]]],[[],3],[[],3],[[],3],[[],3],[[],3],[[],3],[[],3],[[],3],[[],3],[[],3],[[],4],[[],4],[[],4],[[],4],[[],4],[[31,31],31],[[33,34]],[[33,34,20]],0,0,0,0,0,0,0,0,0,0,0,0,[[],39],[[39,39],39],[[39,39]],[[39,39],39],[[39,39]],[39,14],0,0,[[39,39],39],[[39,39]],[[]],[[]],[[]],[[]],[[]],[[]],[39,39],[38,38],[[]],[[]],[[39,39],23],[39,39],[[39,39],17],[[39,39],39],[[],39],[[],38],[[39,39],17],[38,17],[[39,37]],[[34,20],[[12,[38]]]],[[34,20],[[12,[38]]]],[38,39],[[39,24],7],[[39,24],7],[[39,24],7],[[39,24],7],[[39,24],7],0,[[]],[[]],[[]],[14,[[12,[39]]]],[14,39],[14,39],[37,39],[11,34],[39],[[39,39]],[[39,39],39],[[39,39],17],[[]],[[]],[[]],[39,17],[39,17],[38,17],[[34,20,19,39]],[[39,39],17],[[],34],[[19,39],38],[39,39],[[39,39],[[12,[23]]]],[38,19],[38,17],[[39,39]],0,[[39,39,17]],[[39,39],39],[[39,39]],[[39,39],39],[[]],[[]],[[39,39]],[34,11],[[34,20],[[12,[38]]]],[[34,18],[[12,[16]]]],[[11,14,11],10],[11],[[11,14],15],[[],3],[[],3],[[],3],[[],3],[[],3],[[],3],[[],4],[[],4],[[],4],[[39,39],39],[[34,20]],[38,17],[[],11],[11],[11],[17,1],0,0,0,0,[[]],[[]],[28,40],[[]],0,[[]],[[],28],[[],3],[[],3],[[],4],0,0,0,0,0,0,0,0,0,0,0,[11,41],0,0,[[11,14,11],41],[[11,14,11],41],[14,41],[42,1],[[],41],[[],41],[[],41],[[41,42],41],[[],41],0,0,0,0,0,0,0,0,0,0,[[]],[[[36,[43]]]],[[]],[[]],0,0,0,[[],[[12,[[36,[43]]]]]],[[],44],[[],11],[45,36],[42],[[],[[12,[[36,[43]]]]]],[[]],0,[[]],0,0,0,[[],46],0,0,0,0,[[]],0,[47],0,[[]],0,[[],[[12,[[36,[43]]]]]],0,[[],3],[[],3],[[],4],0,[[]],[[]],[[]],[11,47],[[]],0,0,0,[[],3],[[],3],[[],4],[[],47],0,0,0,[[48,[36,[43]]]],[[[36,[43]]]],[[]],[[]],[[]],[[]],[49,28],[48,[[12,[[36,[43]]]]]],[[],[[12,[[36,[43]]]]]],[[]],[[]],[[]],[[]],[[],48],0,[[],3],[[],3],[[],3],[[],3],[[],4],[[],4],0,0,0,0,0,0,[50,46],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],0,[[50,11]],[51,28],[46],[52],[[]],[[]],[[]],[[]],[52,11],[[]],[[]],[[]],[[]],[11],[[],50],[46,52],0,[[],46],[52],0,[[],3],[[],3],[[],3],[[],3],[[],3],[[],3],[[],3],[[],3],[[],4],[[],4],[[],4],[[],4],0,0,0,[[]],[[]],[[]],[[]],[53,[[12,[[36,[43]]]]]],0,[[],[[12,[[36,[43]]]]]],[[],44],[[],11],[54,28],[[]],[[]],[53,47],0,[[]],[[]],[[],53],[[]],[47],[53,[[12,[[36,[43]]]]]],[[],[[12,[[36,[43]]]]]],[[],3],[[],3],[[],3],[[],3],[[],4],[[],4],0,0,0,0,0,0,0,0,[[]],[[]],[[]],[[]],[[]],[[]],0,[55,55],[[]],[[55,55],17],[43],0,[36,[[36,[43]]]],[[]],[[]],[[]],[56,55],[56,44],[56,11],[43,11],0,[43,[[40,[56]]]],[[]],[[]],[[]],[56,17],0,0,[[],43],0,0,0,0,[[]],0,[[],3],[[],3],[[],3],[[],3],[[],3],[[],3],[[],4],[[],4],[[],4],0,0,[[],11],[[],11],[[]],0,0,[[]],[[]],0,0,0,[[]],[[]],0,[[],1],[[],1],0,[[],1],0,0,[[11,11,11,11,11],44],[[]],[[]],[[]],[[]],0,0,0,[[44,11]],0,0,[[],3],[[],3],[[],4],0],"p":[[15,"never"],[3,"Arguments"],[4,"Result"],[3,"TypeId"],[3,"Stdout"],[15,"str"],[6,"Result"],[3,"PanicInfo"],[3,"APP_NAMES"],[3,"Vec"],[15,"usize"],[4,"Option"],[3,"FrameTracker"],[15,"u8"],[3,"String"],[3,"PhysAddr"],[15,"bool"],[3,"VirtAddr"],[3,"PhysPageNum"],[3,"VirtPageNum"],[8,"Clone"],[3,"SimpleRange"],[4,"Ordering"],[3,"Formatter"],[3,"SimpleRangeIterator"],[3,"StackFrameAllocator"],[3,"FRAME_ALLOCATOR"],[3,"UPSafeCell"],[3,"Layout"],[3,"MemorySet"],[3,"MapPermission"],[4,"MapType"],[3,"MapArea"],[3,"PageTable"],[3,"KERNEL_SPACE"],[3,"Arc"],[8,"IntoIterator"],[3,"PageTableEntry"],[3,"PTEFlags"],[3,"RefMut"],[15,"isize"],[15,"i32"],[3,"TaskControlBlock"],[3,"TrapContext"],[3,"INITPROC"],[3,"PidHandle"],[3,"TaskContext"],[3,"TaskManager"],[3,"TASK_MANAGER"],[3,"PidAllocator"],[3,"PID_ALLOCATOR"],[3,"KernelStack"],[3,"Processor"],[3,"PROCESSOR"],[4,"TaskStatus"],[3,"TaskControlBlockInner"],[8,"StepByOne"],[8,"FrameAllocator"]]}\ +"os":{"doc":"The main module and entrypoint","t":"AFAAAAAOOFAAAAAARRRCRRCCRRRRRDLLLLFLLLLFDMLLLLFFFLFLLLDCCDDDDDDDDMAMMMFAAFAAMMFFFFRRDDDDIRGRDDLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMLLLLLLLLLMMKLLLLLLLLLLLLLLLLLLLLLLLLDIGDDMKLLLLLLLMMKLLLMMLFFFLLLLFLLLKLLMMMLLLLLLLLLHHFFFNNDDDEDSSSSMLLMLLLLLMLLLLLLLLLLLLLLLLLLLLMLLFFFLLLFFLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMLMLLLLMLLLFLLFFLFFFLLLLLLLLLLLLLLLLLLLLLLLLLLMSSSDDDSSSSSLLLLLLMMLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMLLLLLLLLLLLLLLLLLLLLLLLLLLMLLLLLLLLLLFFFLLLLLLLLLLLLFFFFDMADLLLLMLLLLLRRRRRRRRRAAFRRFFFFFFFFFRDDDDDDDMFFLLAMMFFFLFFLMLAAMFAMMMFMFMFAFALLLDLLLLLMMMLLLLDDMLFLLLLLLFLLLLLMLLLLLLDDDDMLLLLLLLLLMLLLLLLLLLLLLLFLLMFLMLLLLLLLLLLLLDDMLLLLLMFFFLLLLMLLLFFLFLLLLLLFNNDDENMLLLLLLMLLLLMLLLLLLLLMLLLLLMMLMMMMLMLLLLLLLLLRRFFFDAFFMMMFFMFFMFMDLLLLLMMMLMMLLLM","n":["board","clear_bss","config","console","lang_items","loader","mm","print","println","rust_main","sbi","sync","syscall","task","timer","trap","CLOCK_FREQ","MEMORY_END","MMIO","CLOCK_FREQ","KERNEL_HEAP_SIZE","KERNEL_STACK_SIZE","MEMORY_END","MMIO","PAGE_SIZE","PAGE_SIZE_BITS","TRAMPOLINE","TRAP_CONTEXT","USER_STACK_SIZE","Stdout","borrow","borrow_mut","from","into","print","try_from","try_into","type_id","write_str","panic","APP_NAMES","__private_field","borrow","borrow_mut","deref","from","get_app_data","get_app_data_by_name","get_num_app","into","list_apps","try_from","try_into","type_id","FrameTracker","KERNEL_SPACE","KERNEL_SPACE","KERNEL_SPACE","MapPermission","MemorySet","PageTableEntry","PhysAddr","PhysPageNum","VirtAddr","VirtPageNum","__private_field","address","areas","bits","bits","frame_alloc","frame_allocator","heap_allocator","init","memory_set","page_table","page_table","ppn","remap_test","translated_byte_buffer","translated_refmut","translated_str","PA_WIDTH_SV39","PPN_WIDTH_SV39","PhysAddr","PhysPageNum","SimpleRange","SimpleRangeIterator","StepByOne","VA_WIDTH_SV39","VPNRange","VPN_WIDTH_SV39","VirtAddr","VirtPageNum","aligned","aligned","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","ceil","ceil","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","cmp","cmp","cmp","current","end","eq","eq","eq","eq","floor","floor","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","from","from","get_bytes_array","get_end","get_mut","get_mut","get_pte_array","get_start","indexes","into","into","into","into","into","into","into_iter","into_iter","l","l","new","new","next","page_offset","page_offset","partial_cmp","partial_cmp","partial_cmp","partial_cmp","r","r","step","step","to_owned","to_owned","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","FRAME_ALLOCATOR","FrameAllocator","FrameAllocatorImpl","FrameTracker","StackFrameAllocator","__private_field","alloc","alloc","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","current","current","dealloc","dealloc","deref","drop","end","end","fmt","frame_alloc","frame_allocator_test","frame_dealloc","from","from","from","init","init_frame_allocator","into","into","into","new","new","new","ppn","recycled","recycled","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","HEAP_ALLOCATOR","HEAP_SPACE","handle_alloc_error","heap_test","init_heap","Framed","Identical","KERNEL_SPACE","MapArea","MapPermission","MapType","MemorySet","R","U","W","X","__private_field","activate","all","areas","bitand","bitand_assign","bitor","bitor_assign","bits","bits","bitxor","bitxor_assign","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","cmp","complement","contains","copy_data","data_frames","deref","difference","ebss","edata","ekernel","empty","eq","eq","erodata","etext","extend","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from_another","from_bits","from_bits_truncate","from_bits_unchecked","from_elf","from_existed_user","from_iter","hash","insert","insert_framed_area","intersection","intersects","into","into","into","into","into","is_all","is_empty","map","map_one","map_perm","map_trampoline","map_type","new","new_bare","new_kernel","not","page_table","partial_cmp","push","recycle_data_pages","remap_test","remove","remove_area_with_start_vpn","sbss_with_stack","sdata","set","srodata","stext","strampoline","sub","sub_assign","symmetric_difference","to_owned","to_owned","toggle","token","translate","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","union","unmap","unmap_one","vpn_range","A","D","G","PTEFlags","PageTable","PageTableEntry","R","U","V","W","X","all","bitand","bitand_assign","bitor","bitor_assign","bits","bits","bits","bitxor","bitxor_assign","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","cmp","complement","contains","difference","empty","empty","eq","executable","extend","find_pte","find_pte_create","flags","fmt","fmt","fmt","fmt","fmt","frames","from","from","from","from_bits","from_bits_truncate","from_bits_unchecked","from_iter","from_token","hash","insert","intersection","intersects","into","into","into","is_all","is_empty","is_valid","map","new","new","not","partial_cmp","ppn","readable","remove","root_ppn","set","sub","sub_assign","symmetric_difference","to_owned","to_owned","toggle","token","translate","translate_va","translated_byte_buffer","translated_refmut","translated_str","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","union","unmap","writable","console_getchar","console_putchar","set_timer","shutdown","UPSafeCell","inner","up","UPSafeCell","borrow","borrow_mut","exclusive_access","from","inner","into","new","try_from","try_into","type_id","SYSCALL_EXEC","SYSCALL_EXIT","SYSCALL_FORK","SYSCALL_GETPID","SYSCALL_GET_TIME","SYSCALL_READ","SYSCALL_WAITPID","SYSCALL_WRITE","SYSCALL_YIELD","fs","process","syscall","FD_STDIN","FD_STDOUT","sys_read","sys_write","sys_exec","sys_exit","sys_fork","sys_get_time","sys_getpid","sys_waitpid","sys_yield","IDLE_PID","INITPROC","KernelStack","PidAllocator","PidHandle","Processor","TaskContext","TaskManager","__private_field","add_initproc","add_task","borrow","borrow_mut","context","current","current","current_task","current_trap_cx","current_user_token","deref","exit_current_and_run_next","fetch_task","from","idle_task_cx","into","manager","pid","pid","pid_alloc","processor","ra","ready_queue","recycled","run_tasks","s","schedule","sp","suspend_current_and_run_next","switch","take_current_task","task","try_from","try_into","type_id","TaskContext","borrow","borrow_mut","from","goto_trap_return","into","ra","s","sp","try_from","try_into","type_id","zero_init","TASK_MANAGER","TaskManager","__private_field","add","add_task","borrow","borrow","borrow_mut","borrow_mut","deref","fetch","fetch_task","from","from","into","into","new","ready_queue","try_from","try_from","try_into","try_into","type_id","type_id","KernelStack","PID_ALLOCATOR","PidAllocator","PidHandle","__private_field","alloc","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","current","dealloc","deref","drop","drop","from","from","from","from","get_top","into","into","into","into","kernel_stack_position","new","new","pid","pid_alloc","push_on_top","recycled","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","PROCESSOR","Processor","__private_field","borrow","borrow","borrow_mut","borrow_mut","current","current","current_task","current_trap_cx","current_user_token","deref","from","from","get_idle_task_cx_ptr","idle_task_cx","into","into","new","run_tasks","schedule","take_current","take_current_task","try_from","try_from","try_into","try_into","type_id","type_id","__switch","Ready","Running","TaskControlBlock","TaskControlBlockInner","TaskStatus","Zombie","base_size","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","children","clone","clone_into","eq","exec","exit_code","fork","from","from","from","get_status","get_trap_cx","get_user_token","getpid","inner","inner_exclusive_access","into","into","into","is_zombie","kernel_stack","memory_set","new","parent","pid","task_cx","task_status","to_owned","trap_cx_ppn","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","MSEC_PER_SEC","TICKS_PER_SEC","get_time","get_time_ms","set_next_trigger","TrapContext","context","enable_timer_interrupt","init","kernel_satp","kernel_sp","sepc","set_kernel_trap_entry","set_user_trap_entry","sstatus","trap_from_kernel","trap_handler","trap_handler","trap_return","x","TrapContext","app_init_context","borrow","borrow_mut","from","into","kernel_satp","kernel_sp","sepc","set_sp","sstatus","trap_handler","try_from","try_into","type_id","x"],"q":[[0,"os"],[16,"os::board"],[19,"os::config"],[29,"os::console"],[39,"os::lang_items"],[40,"os::loader"],[54,"os::mm"],[82,"os::mm::address"],[203,"os::mm::frame_allocator"],[252,"os::mm::heap_allocator"],[257,"os::mm::memory_set"],[389,"os::mm::page_table"],[490,"os::sbi"],[494,"os::sync"],[497,"os::sync::up"],[508,"os::syscall"],[520,"os::syscall::fs"],[524,"os::syscall::process"],[531,"os::task"],[575,"os::task::context"],[588,"os::task::manager"],[612,"os::task::pid"],[659,"os::task::processor"],[689,"os::task::switch"],[690,"os::task::task"],[741,"os::timer"],[746,"os::trap"],[761,"os::trap::context"],[777,"core::fmt"],[778,"core::result"],[779,"core::any"],[780,"core::fmt"],[781,"alloc::vec"],[782,"core::option"],[783,"alloc::string"],[784,"core::marker"],[785,"core::cmp"],[786,"core::cmp"],[787,"core::cmp"],[788,"alloc::sync"],[789,"core::iter::traits::collect"],[790,"core::hash"],[791,"core::cell"],[792,"core::marker"]],"d":["Constants used in rCore for qemu","clear BSS segment","Constants used in rCore","SBI console driver, for text output","The panic handler","Loading user applications into memory","Memory management implementation","print string macro","println string macro","the rust entry-point of os","SBI call wrappers","Synchronization and interior mutability primitives","Implementation of syscalls","Task management implementation","RISC-V timer-related functionality","Trap handling functionality","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Calls U::from(self).","","","","","","","All of app’s name","","","","","Returns the argument unchanged.","get applications data","get app data from name","get app number","Calls U::from(self).","list all apps","","","","manage a frame which has the same lifecycle as the tracker","","","a memory set instance through lazy_static! managing kernel …","map permission corresponding to that in pte: R W X U","memory set structure, controls virtual-memory space","page table entry structure","physical address","physical page number","virtual address","virtual page number","","Implementation of physical and virtual address and page …","","","PTE","allocate a frame","Implementation of FrameAllocator which controls all the …","The global allocator","initiate heap allocator, frame allocator and kernel space","Implementation of MapArea and MemorySet.","Implementation of PageTableEntry and PageTable.","","","Check PageTable running correctly","translate a pointer to a mutable u8 Vec through page table","translate a generic through page table and return a …","translate a pointer to a mutable u8 Vec end with \\\\0 …","physical address","","physical address","physical page number","a simple range structure for type T","iterator for the simple range structure","","","a simple range structure for virtual page number","","virtual address","virtual page number","Check page aligned","Check page aligned","","","","","","","","","","","","","PhysAddr->PhysPageNum","VirtAddr->VirtPageNum","","","","","","","","","","","","","","","","","","","","","PhysAddr->PhysPageNum","VirtAddr->VirtPageNum","","","","","Returns the argument unchanged.","Returns the argument unchanged.","","","","","Returns the argument unchanged.","","Returns the argument unchanged.","","Returns the argument unchanged.","","","Returns the argument unchanged.","","","Get mutable reference to PhysAddr value","","Get PageTableEntry on PhysPageNum","","Return VPN 3 level index","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","","","","","","","","Get page offset","Get page offset","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","frame allocator instance through lazy_static!","","","manage a frame which has the same lifecycle as the tracker","an implementation for frame allocator","","","","","","","","","","","","","","","","","","","allocate a frame","a simple test for frame allocator","deallocate a frame","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","initiate the frame allocator using ekernel and MEMORY_END","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","","Create an empty FrameTracker","","","","","","","","","","","","","","heap allocator instance","heap space ([u8; KERNEL_HEAP_SIZE])","panic when heap allocation error occurs","","initiate heap allocator","","","a memory set instance through lazy_static! managing kernel …","map area structure, controls a contiguous piece of virtual …","map permission corresponding to that in pte: R W X U","map type for memory set: identical or framed","memory set structure, controls virtual-memory space","Readable","Accessible in U mode","Writable","Excutable","","Refresh TLB with sfence.vma","Returns the set containing all flags.","","Returns the intersection between the two sets of flags.","Disables all flags disabled in the set.","Returns the union of the two sets of flags.","Adds the set of flags.","Returns the raw value of the flags currently stored.","","Returns the left flags, but with all the right flags …","Toggles the set of flags.","","","","","","","","","","","","","","","","Returns the complement of this set of flags.","Returns true if all of the flags in other are contained …","data: start-aligned but maybe with shorter length assume …","","","Returns the difference between the flags in self and other.","","","","Returns an empty set of flags.","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","Convert from underlying bit representation, unless that …","Convert from underlying bit representation, dropping any …","Convert from underlying bit representation, preserving all …","Include sections in elf and trampoline and TrapContext and …","Clone a same MemorySet","","","Inserts the specified flags in-place.","Assume that no conflicts.","Returns the intersection between the flags in self and …","Returns true if there are flags common to both self and …","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Returns true if all flags are currently set.","Returns true if no flags are currently stored.","","","","Mention that trampoline is not collected by areas.","","","Create an empty MemorySet","Without kernel stacks.","Returns the complement of this set of flags.","","","","Remove all MapArea","Check PageTable running correctly","Removes the specified flags in-place.","Remove MapArea that starts with start_vpn","","","Inserts or removes the specified flags depending on the …","","","","Returns the set difference of the two sets of flags.","Disables all flags enabled in the set.","Returns the symmetric difference between the flags in self …","","","Toggles the specified flags in-place.","Get pagetable root_ppn","Translate throuth pagetable","","","","","","","","","","","","","","","","Returns the union of between the flags in self and other.","","","","","","","","","page table entry structure","","","","","","Returns the set containing all flags.","Returns the intersection between the two sets of flags.","Disables all flags disabled in the set.","Returns the union of the two sets of flags.","Adds the set of flags.","Returns the raw value of the flags currently stored.","","PTE","Returns the left flags, but with all the right flags …","Toggles the set of flags.","","","","","","","","","","","","Returns the complement of this set of flags.","Returns true if all of the flags in other are contained …","Returns the difference between the flags in self and other.","Returns an empty set of flags.","Return an empty PTE","","Check PTE executable","","","","Return 10bit flag","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Convert from underlying bit representation, unless that …","Convert from underlying bit representation, dropping any …","Convert from underlying bit representation, preserving all …","","Temporarily used to get arguments from user space.","","Inserts the specified flags in-place.","Returns the intersection between the flags in self and …","Returns true if there are flags common to both self and …","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Returns true if all flags are currently set.","Returns true if no flags are currently stored.","Check PTE valid","","","Create a PTE from ppn","Returns the complement of this set of flags.","","Return 44bit ppn","Check PTE readable","Removes the specified flags in-place.","","Inserts or removes the specified flags depending on the …","Returns the set difference of the two sets of flags.","Disables all flags enabled in the set.","Returns the symmetric difference between the flags in self …","","","Toggles the specified flags in-place.","","","","translate a pointer to a mutable u8 Vec through page table","translate a generic through page table and return a …","translate a pointer to a mutable u8 Vec end with \\\\0 …","","","","","","","","","","Returns the union of between the flags in self and other.","","Check PTE writable","use sbi call to getchar from console (qemu uart handler)","use sbi call to putchar in console (qemu uart handler)","use sbi call to set timer","use sbi call to shutdown the kernel","Wrap a static data structure inside it so that we are able …","inner data","Uniprocessor interior mutability primitives","Wrap a static data structure inside it so that we are able …","","","Exclusive access inner data in UPSafeCell. Panic if the …","Returns the argument unchanged.","inner data","Calls U::from(self).","User is responsible to guarantee that inner struct is only …","","","","","","","","","","","","","File and filesystem-related syscalls","","handle syscall exception with syscall_id and other …","","","","","","","","","","If there is not a child process whose pid is same as …","","pid of usertests app in make run TEST=1","Globle process that init user shell","Kernelstack for app","Pid Allocator struct","Bind pid lifetime to PidHandle","Processor management structure","task context structure containing some registers","A array of TaskControlBlock that is thread-safe","","Add init process to the manager","Interface offered to add task","","","Implementation of TaskContext","","The task currently executing on the current processor","Get running task","Get the mutable reference to trap context of current task","Get token of the address space of current task","","Exit the current ‘Running’ task and run the next task …","Interface offered to pop the first task","Returns the argument unchanged.","The basic control flow of each core, helping to select and …","Calls U::from(self).","Implementation of TaskManager","Implementation of PidAllocator","","Allocate a pid from PID_ALLOCATOR","Implementation of Processor and Intersection of control …","return address ( e.g. __restore ) of __switch ASM function","","","The main part of process execution and scheduling Loop …","s0-11 register, callee saved","Return to idle control flow for new scheduling","kernel stack pointer of app","Suspend the current ‘Running’ task and run the next …","Wrap switch.S as a function","Take the current task,leaving a None in its place","Implementation of TaskControlBlock","","","","task context structure containing some registers","","","Returns the argument unchanged.","set Task Context{__restore ASM funciton: trap_return, sp: …","Calls U::from(self).","return address ( e.g. __restore ) of __switch ASM function","s0-11 register, callee saved","kernel stack pointer of app","","","","init task context","","A array of TaskControlBlock that is thread-safe","","Add a task to TaskManager","Interface offered to add task","","","","","","Remove the first task and return it,or None if TaskManager …","Interface offered to pop the first task","Returns the argument unchanged.","Returns the argument unchanged.","Calls U::from(self).","Calls U::from(self).","Creat an empty TaskManager","","","","","","","","Kernelstack for app","","Pid Allocator struct","Bind pid lifetime to PidHandle","","Allocate a pid","","","","","","","","","","Recycle a pid","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Get the value on the top of kernelstack","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Return (bottom, top) of a kernel stack in kernel space.","Create an empty PidAllocator","Create a kernelstack from pid","","Allocate a pid from PID_ALLOCATOR","Push a value on top of kernelstack","","","","","","","","","","","","","","","Processor management structure","","","","","","Get current task in cloning semanteme","The task currently executing on the current processor","Get running task","Get the mutable reference to trap context of current task","Get token of the address space of current task","","Returns the argument unchanged.","Returns the argument unchanged.","Get mutable reference to idle_task_cx","The basic control flow of each core, helping to select and …","Calls U::from(self).","Calls U::from(self).","Create an empty Processor","The main part of process execution and scheduling Loop …","Return to idle control flow for new scheduling","Get current task in moving semanteme","Take the current task,leaving a None in its place","","","","","","","","","","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","","","","","","","","","","","","","","","","","","","","","","get current time","get current time in microseconds","set the next timer interrupt","trap context structure containing sstatus, sepc and …","Implementation of TrapContext","enable timer interrupt in sie CSR","initialize CSR stvec as the entry of __alltraps","Addr of Page Table","kernel stack","CSR sepc","","","CSR sstatus ","Unimplement: traps/interrupts/exceptions from kernel mode …","handle an interrupt, exception, or system call from user …","Addr of trap_handler function","set the new addr of __restore asm function in TRAMPOLINE …","general regs[0..31]","trap context structure containing sstatus, sepc and …","init app context","","","Returns the argument unchanged.","Calls U::from(self).","Addr of Page Table","kernel stack","CSR sepc","set stack pointer to x_2 reg (sp)","CSR sstatus ","Addr of trap_handler function","","","","general regs[0..31]"],"i":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,6,6,6,0,6,6,6,6,0,0,10,10,10,10,10,0,0,0,10,0,10,10,10,0,0,0,0,0,0,0,0,0,0,0,44,0,39,40,32,0,0,0,0,0,0,39,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,18,20,34,18,20,21,22,23,34,18,20,21,22,23,18,20,18,20,21,22,23,18,20,21,22,23,18,20,21,22,34,34,18,20,21,22,18,20,18,20,21,22,34,18,18,18,20,20,20,21,21,21,22,22,22,23,21,23,18,21,21,23,22,34,18,20,21,22,23,34,23,67,23,34,23,34,18,20,18,20,21,22,67,23,24,22,18,20,21,22,23,34,18,20,21,22,23,34,18,20,21,22,23,34,18,20,21,22,23,0,0,0,0,0,36,68,35,16,35,36,16,35,36,35,69,68,35,36,16,35,69,16,0,0,0,16,35,36,35,0,16,35,36,68,16,35,16,35,69,16,35,36,16,35,36,16,35,36,0,0,0,0,0,41,41,0,0,0,0,0,40,40,40,40,44,39,40,39,40,40,40,40,40,40,40,40,39,42,44,41,40,39,42,44,41,40,41,40,41,40,40,40,40,42,42,44,40,0,0,0,40,41,40,0,0,40,41,40,40,40,40,40,39,42,44,41,40,42,40,40,40,39,39,40,40,40,39,40,40,39,42,44,41,40,40,40,42,42,42,39,42,42,39,39,40,39,40,39,39,0,40,39,0,0,40,0,0,0,40,40,40,41,40,40,39,39,39,42,44,41,40,39,42,44,41,40,39,42,44,41,40,40,42,42,42,48,48,48,0,0,0,48,48,48,48,48,48,48,48,48,48,48,48,32,48,48,43,48,32,43,48,32,48,32,48,32,48,48,48,48,48,32,48,32,48,43,43,32,48,48,48,48,48,43,43,48,32,48,48,48,48,43,48,48,48,48,43,48,32,48,48,32,43,43,32,48,48,32,32,48,43,48,48,48,48,48,32,48,43,43,43,0,0,0,43,48,32,43,48,32,43,48,32,48,43,32,0,0,0,0,0,37,0,0,37,37,37,37,37,37,37,37,37,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,54,0,0,54,54,0,59,63,0,0,0,54,0,0,54,63,54,0,0,61,0,0,56,57,59,0,56,0,56,0,0,0,0,54,54,54,0,56,56,56,56,56,56,56,56,56,56,56,56,0,0,58,57,0,57,58,57,58,58,57,0,57,58,57,58,57,57,57,58,57,58,57,58,0,0,0,0,60,59,59,55,61,60,59,55,61,60,59,59,60,55,61,59,55,61,60,61,59,55,61,60,0,59,61,61,0,61,59,59,55,61,60,59,55,61,60,59,55,61,60,0,0,64,63,64,63,64,63,63,0,0,0,64,63,64,63,63,63,64,63,0,0,63,0,63,64,63,64,63,64,0,65,65,0,0,0,65,66,52,66,65,52,66,65,66,65,65,65,52,66,52,52,66,65,66,66,66,52,52,52,52,66,65,66,52,66,52,66,52,66,66,65,66,52,66,65,52,66,65,52,66,65,0,0,0,0,0,0,0,0,0,53,53,53,0,0,53,0,0,53,0,53,0,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53],"f":[0,[[],1],0,0,0,0,0,0,0,[[],2],0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,[-1,-2,[],[]],[-1,-2,[],[]],[-1,-1,[]],[-1,-2,[],[]],[3,1],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,5,[]],[[6,7],8],[9,2],0,0,[-1,-2,[],[]],[-1,-2,[],[]],[10,[[11,[7]]]],[-1,-1,[]],[12,[[14,[13]]]],[7,[[15,[[14,[13]]]]]],[[],12],[-1,-2,[],[]],[[],1],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,5,[]],0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,[[],[[15,[16]]]],0,0,[[],1],0,0,0,0,[[],1],[[12,13,12],[[11,[[14,[13]]]]]],[12,-1,[]],[[12,13],17],0,0,0,0,0,0,0,0,0,0,0,0,[18,19],[20,19],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[18,21],[20,22],[18,18],[20,20],[21,21],[22,22],[[[23,[-1]]],[[23,[-1]]],[24,25,26,27,28,29]],[[-1,-2],1,[],[]],[[-1,-2],1,[],[]],[[-1,-2],1,[],[]],[[-1,-2],1,[],[]],[[-1,-2],1,[],[]],[[18,18],30],[[20,20],30],[[21,21],30],[[22,22],30],0,0,[[18,18],19],[[20,20],19],[[21,21],19],[[22,22],19],[18,21],[20,22],[[18,31],8],[[20,31],8],[[21,31],8],[[22,31],8],[-1,-1,[]],[-1,-1,[]],[21,18],[12,18],[12,20],[22,20],[-1,-1,[]],[12,21],[-1,-1,[]],[18,21],[-1,-1,[]],[12,22],[20,22],[-1,-1,[]],[21,[[14,[13]]]],[[[23,[-1]]],-1,[24,25,26,27,28]],[18,-1,[]],[21,-1,[]],[21,[[14,[32]]]],[[[23,[-1]]],-1,[24,25,26,27,28]],[22,[[33,[12]]]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[[[23,[-1]]],[],[24,25,26,27,28]],0,0,[[-1,-1],[[34,[-1]]],[24,25,26,27,28]],[[-1,-1],[[23,[-1]]],[24,25,26,27,28]],[[[34,[-1]]],15,[24,25,26,27,28]],[18,12],[20,12],[[18,18],[[15,[30]]]],[[20,20],[[15,[30]]]],[[21,21],[[15,[30]]]],[[22,22],[[15,[30]]]],0,0,[-1,1,[]],[22,1],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,5,[]],[-1,5,[]],[-1,5,[]],[-1,5,[]],[-1,5,[]],[-1,5,[]],0,0,0,0,0,0,[-1,[[15,[21]]],[]],[35,[[15,[21]]]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],0,0,[[-1,21],1,[]],[[35,21],1],[36,[[37,[35]]]],[16,1],0,0,[[16,31],8],[[],[[15,[16]]]],[[],1],[21,1],[-1,-1,[]],[-1,-1,[]],[-1,-1,[]],[[35,21,21],1],[[],1],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[[],-1,[]],[21,16],[[],35],0,0,0,[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,5,[]],[-1,5,[]],[-1,5,[]],0,0,[38,2],[[],1],[[],1],0,0,0,0,0,0,0,0,0,0,0,0,[39,1],[[],40],0,[[40,40],40],[[40,40],1],[[40,40],40],[[40,40],1],[40,13],0,[[40,40],40],[[40,40],1],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[41,41],[40,40],[[-1,-2],1,[],[]],[[-1,-2],1,[],[]],[[40,40],30],[40,40],[[40,40],19],[[42,43,[14,[13]]],1],0,[44,[[45,[[37,[39]]]]]],[[40,40],40],0,0,0,[[],40],[[41,41],19],[[40,40],19],0,0,[[40,-1],1,46],[[41,31],8],[[40,31],8],[[40,31],8],[[40,31],8],[[40,31],8],[[40,31],8],[-1,-1,[]],[-1,-1,[]],[-1,-1,[]],[-1,-1,[]],[-1,-1,[]],[42,42],[13,[[15,[40]]]],[13,40],[13,40],[[[14,[13]]],[[1,[39,12,12]]]],[39,39],[-1,40,46],[[40,-1],1,47],[[40,40],1],[[39,20,20,40],1],[[40,40],40],[[40,40],19],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[40,19],[40,19],[[42,43],1],[[42,43,22],1],0,[39,1],0,[[20,20,41,40],42],[[],39],[[],39],[40,40],0,[[40,40],[[15,[30]]]],[[39,42,[15,[[14,[13]]]]],1],[39,1],[[],1],[[40,40],1],[[39,22],1],0,0,[[40,40,19],1],0,0,0,[[40,40],40],[[40,40],1],[[40,40],40],[-1,-2,[],[]],[-1,-2,[],[]],[[40,40],1],[39,12],[[39,22],[[15,[32]]]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,5,[]],[-1,5,[]],[-1,5,[]],[-1,5,[]],[-1,5,[]],[[40,40],40],[[42,43],1],[[42,43,22],1],0,0,0,0,0,0,0,0,0,0,0,0,[[],48],[[48,48],48],[[48,48],1],[[48,48],48],[[48,48],1],[48,13],0,0,[[48,48],48],[[48,48],1],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[48,48],[32,32],[[-1,-2],1,[],[]],[[-1,-2],1,[],[]],[[48,48],30],[48,48],[[48,48],19],[[48,48],48],[[],48],[[],32],[[48,48],19],[32,19],[[48,-1],1,46],[[43,22],[[15,[32]]]],[[43,22],[[15,[32]]]],[32,48],[[48,31],8],[[48,31],8],[[48,31],8],[[48,31],8],[[48,31],8],0,[-1,-1,[]],[-1,-1,[]],[-1,-1,[]],[13,[[15,[48]]]],[13,48],[13,48],[-1,48,46],[12,43],[[48,-1],1,47],[[48,48],1],[[48,48],48],[[48,48],19],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[48,19],[48,19],[32,19],[[43,22,21,48],1],[[],43],[[21,48],32],[48,48],[[48,48],[[15,[30]]]],[32,21],[32,19],[[48,48],1],0,[[48,48,19],1],[[48,48],48],[[48,48],1],[[48,48],48],[-1,-2,[],[]],[-1,-2,[],[]],[[48,48],1],[43,12],[[43,22],[[15,[32]]]],[[43,20],[[15,[18]]]],[[12,13,12],[[11,[[14,[13]]]]]],[12,-1,[]],[[12,13],17],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,5,[]],[-1,5,[]],[-1,5,[]],[[48,48],48],[[43,22],1],[32,19],[[],12],[12,1],[12,1],[19,2],0,0,0,0,[-1,-2,[],[]],[-1,-2,[],[]],[[[37,[-1]]],[[49,[-1]]],[]],[-1,-1,[]],0,[-1,-2,[],[]],[-1,[[37,[-1]]],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,5,[]],0,0,0,0,0,0,0,0,0,0,0,[[12,[33,[12]]],50],0,0,[[12,13,12],50],[[12,13,12],50],[13,50],[51,2],[[],50],[[],50],[[],50],[[50,51],50],[[],50],0,0,0,0,0,0,0,0,0,[[],1],[[[45,[52]]],1],[-1,-2,[],[]],[-1,-2,[],[]],0,0,0,[[],[[15,[[45,[52]]]]]],[[],53],[[],12],[54,[[45,[52]]]],[51,1],[[],[[15,[[45,[52]]]]]],[-1,-1,[]],0,[-1,-2,[],[]],0,0,0,[[],55],0,0,0,0,[[],1],0,[56,1],0,[[],1],0,[[],[[15,[[45,[52]]]]]],0,[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,5,[]],0,[-1,-2,[],[]],[-1,-2,[],[]],[-1,-1,[]],[12,56],[-1,-2,[],[]],0,0,0,[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,5,[]],[[],56],0,0,0,[[57,[45,[52]]],1],[[[45,[52]]],1],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[58,[[37,[57]]]],[57,[[15,[[45,[52]]]]]],[[],[[15,[[45,[52]]]]]],[-1,-1,[]],[-1,-1,[]],[-1,-2,[],[]],[-1,-2,[],[]],[[],57],0,[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,5,[]],[-1,5,[]],0,0,0,0,0,[59,55],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],0,[[59,12],1],[60,[[37,[59]]]],[55,1],[61,1],[-1,-1,[]],[-1,-1,[]],[-1,-1,[]],[-1,-1,[]],[61,12],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[12,[[1,[12,12]]]],[[],59],[55,61],0,[[],55],[[61,-1],[],62],0,[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,5,[]],[-1,5,[]],[-1,5,[]],[-1,5,[]],0,0,0,[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[63,[[15,[[45,[52]]]]]],0,[[],[[15,[[45,[52]]]]]],[[],53],[[],12],[64,[[37,[63]]]],[-1,-1,[]],[-1,-1,[]],[63,56],0,[-1,-2,[],[]],[-1,-2,[],[]],[[],63],[[],1],[56,1],[63,[[15,[[45,[52]]]]]],[[],[[15,[[45,[52]]]]]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,5,[]],[-1,5,[]],0,0,0,0,0,0,0,0,[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],0,[65,65],[[-1,-2],1,[],[]],[[65,65],19],[[52,[14,[13]]],1],0,[[[45,[52]]],[[45,[52]]]],[-1,-1,[]],[-1,-1,[]],[-1,-1,[]],[66,65],[66,53],[66,12],[52,12],0,[52,[[49,[66]]]],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-2,[],[]],[66,19],0,0,[[[14,[13]]],52],0,0,0,0,[-1,-2,[],[]],0,[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,5,[]],[-1,5,[]],[-1,5,[]],0,0,[[],12],[[],12],[[],1],0,0,[[],1],[[],1],0,0,0,[[],1],[[],1],0,[[],2],[[],2],0,[[],2],0,0,[[12,12,12,12,12],53],[-1,-2,[],[]],[-1,-2,[],[]],[-1,-1,[]],[-1,-2,[],[]],0,0,0,[[53,12],1],0,0,[-1,[[4,[-2]]],[],[]],[-1,[[4,[-2]]],[],[]],[-1,5,[]],0],"c":[],"p":[[15,"tuple"],[15,"never"],[3,"Arguments",777],[4,"Result",778],[3,"TypeId",779],[3,"Stdout",29],[15,"str"],[6,"Result",777],[3,"PanicInfo",780],[3,"APP_NAMES",40],[3,"Vec",781],[15,"usize"],[15,"u8"],[15,"slice"],[4,"Option",782],[3,"FrameTracker",203],[3,"String",783],[3,"PhysAddr",82],[15,"bool"],[3,"VirtAddr",82],[3,"PhysPageNum",82],[3,"VirtPageNum",82],[3,"SimpleRange",82],[8,"StepByOne",82],[8,"Copy",784],[8,"PartialEq",785],[8,"PartialOrd",785],[8,"Debug",777],[8,"Clone",786],[4,"Ordering",785],[3,"Formatter",777],[3,"PageTableEntry",389],[15,"array"],[3,"SimpleRangeIterator",82],[3,"StackFrameAllocator",203],[3,"FRAME_ALLOCATOR",203],[3,"UPSafeCell",497],[3,"Layout",787],[3,"MemorySet",257],[3,"MapPermission",257],[4,"MapType",257],[3,"MapArea",257],[3,"PageTable",389],[3,"KERNEL_SPACE",257],[3,"Arc",788],[8,"IntoIterator",789],[8,"Hasher",790],[3,"PTEFlags",389],[3,"RefMut",791],[15,"isize"],[15,"i32"],[3,"TaskControlBlock",690],[3,"TrapContext",761],[3,"INITPROC",531],[3,"PidHandle",612],[3,"TaskContext",575],[3,"TaskManager",588],[3,"TASK_MANAGER",588],[3,"PidAllocator",612],[3,"PID_ALLOCATOR",612],[3,"KernelStack",612],[8,"Sized",784],[3,"Processor",659],[3,"PROCESSOR",659],[4,"TaskStatus",690],[3,"TaskControlBlockInner",690],[6,"VPNRange",82],[8,"FrameAllocator",203],[6,"FrameAllocatorImpl",203]]}\ }'); if (typeof window !== 'undefined' && window.initSearch) {window.initSearch(searchIndex)}; if (typeof exports !== 'undefined') {exports.searchIndex = searchIndex}; diff --git a/ch5/search.js b/ch5/search.js deleted file mode 100644 index d35a7db8..00000000 --- a/ch5/search.js +++ /dev/null @@ -1 +0,0 @@ -"use strict";(function(){const itemTypes=["mod","externcrate","import","struct","enum","fn","type","static","trait","impl","tymethod","method","structfield","variant","macro","primitive","associatedtype","constant","associatedconstant","union","foreigntype","keyword","existential","attr","derive","traitalias",];const TY_PRIMITIVE=itemTypes.indexOf("primitive");const TY_KEYWORD=itemTypes.indexOf("keyword");const ROOT_PATH=typeof window!=="undefined"?window.rootPath:"../";function hasOwnPropertyRustdoc(obj,property){return Object.prototype.hasOwnProperty.call(obj,property)}function printTab(nb){let iter=0;let foundCurrentTab=false;let foundCurrentResultSet=false;onEachLazy(document.getElementById("titles").childNodes,elem=>{if(nb===iter){addClass(elem,"selected");foundCurrentTab=true}else{removeClass(elem,"selected")}iter+=1});iter=0;onEachLazy(document.getElementById("results").childNodes,elem=>{if(nb===iter){addClass(elem,"active");foundCurrentResultSet=true}else{removeClass(elem,"active")}iter+=1});if(foundCurrentTab&&foundCurrentResultSet){searchState.currentTab=nb}else if(nb!==0){printTab(0)}}const levenshtein_row2=[];function levenshtein(s1,s2){if(s1===s2){return 0}const s1_len=s1.length,s2_len=s2.length;if(s1_len&&s2_len){let i1=0,i2=0,a,b,c,c2;const row=levenshtein_row2;while(i1-".indexOf(c)!==-1}function isStopCharacter(c){return isWhitespace(c)||isEndCharacter(c)}function isErrorCharacter(c){return"()".indexOf(c)!==-1}function itemTypeFromName(typename){for(let i=0,len=itemTypes.length;i0){throw new Error("Cannot use literal search when there is more than one element")}parserState.pos+=1;const start=parserState.pos;const end=getIdentEndPosition(parserState);if(parserState.pos>=parserState.length){throw new Error("Unclosed `\"`")}else if(parserState.userQuery[end]!=="\""){throw new Error(`Unexpected \`${parserState.userQuery[end]}\` in a string element`)}else if(start===end){throw new Error("Cannot have empty string element")}parserState.pos+=1;query.literalSearch=true}function isPathStart(parserState){return parserState.userQuery.slice(parserState.pos,parserState.pos+2)==="::"}function isReturnArrow(parserState){return parserState.userQuery.slice(parserState.pos,parserState.pos+2)==="->"}function isIdentCharacter(c){return(c==="_"||(c>="0"&&c<="9")||(c>="a"&&c<="z")||(c>="A"&&c<="Z"))}function isSeparatorCharacter(c){return c===","||isWhitespaceCharacter(c)}function isWhitespaceCharacter(c){return c===" "||c==="\t"}function createQueryElement(query,parserState,name,generics,isInGenerics){if(name==="*"||(name.length===0&&generics.length===0)){return}if(query.literalSearch&&parserState.totalElems-parserState.genericsElems>0){throw new Error("You cannot have more than one element if you use quotes")}const pathSegments=name.split("::");if(pathSegments.length>1){for(let i=0,len=pathSegments.length;i=end){throw new Error("Found generics without a path")}parserState.pos+=1;getItemsBefore(query,parserState,generics,">")}if(start>=end&&generics.length===0){return}elems.push(createQueryElement(query,parserState,parserState.userQuery.slice(start,end),generics,isInGenerics))}function getItemsBefore(query,parserState,elems,endChar){let foundStopChar=true;while(parserState.pos"){extra="`<`"}else if(endChar===""){extra="`->`"}throw new Error("Unexpected `"+c+"` after "+extra)}if(!foundStopChar){if(endChar!==""){throw new Error(`Expected \`,\`, \` \` or \`${endChar}\`, found \`${c}\``)}throw new Error(`Expected \`,\` or \` \`, found \`${c}\``)}const posBefore=parserState.pos;getNextElem(query,parserState,elems,endChar===">");if(posBefore===parserState.pos){parserState.pos+=1}foundStopChar=false}parserState.pos+=1}function checkExtraTypeFilterCharacters(parserState){const query=parserState.userQuery;for(let pos=0;pos"){if(isReturnArrow(parserState)){break}throw new Error(`Unexpected \`${c}\` (did you mean \`->\`?)`)}throw new Error(`Unexpected \`${c}\``)}else if(c===":"&&!isPathStart(parserState)){if(parserState.typeFilter!==null){throw new Error("Unexpected `:`")}if(query.elems.length===0){throw new Error("Expected type filter before `:`")}else if(query.elems.length!==1||parserState.totalElems!==1){throw new Error("Unexpected `:`")}else if(query.literalSearch){throw new Error("You cannot use quotes on type filter")}checkExtraTypeFilterCharacters(parserState);parserState.typeFilter=query.elems.pop().name;parserState.pos+=1;parserState.totalElems=0;query.literalSearch=false;foundStopChar=true;continue}if(!foundStopChar){if(parserState.typeFilter!==null){throw new Error(`Expected \`,\`, \` \` or \`->\`, found \`${c}\``)}throw new Error(`Expected \`,\`, \` \`, \`:\` or \`->\`, found \`${c}\``)}before=query.elems.length;getNextElem(query,parserState,query.elems,false);if(query.elems.length===before){parserState.pos+=1}foundStopChar=false}while(parserState.pos`")}break}else{parserState.pos+=1}}}function newParsedQuery(userQuery){return{original:userQuery,userQuery:userQuery.toLowerCase(),typeFilter:NO_TYPE_FILTER,elems:[],returned:[],foundElems:0,literalSearch:false,error:null,}}function buildUrl(search,filterCrates){let extra="?search="+encodeURIComponent(search);if(filterCrates!==null){extra+="&filter-crate="+encodeURIComponent(filterCrates)}return getNakedUrl()+extra+window.location.hash}function getFilterCrates(){const elem=document.getElementById("crate-search");if(elem&&elem.value!=="All crates"&&hasOwnPropertyRustdoc(rawSearchIndex,elem.value)){return elem.value}return null}function parseQuery(userQuery){userQuery=userQuery.trim();const parserState={length:userQuery.length,pos:0,totalElems:0,genericsElems:0,typeFilter:null,userQuery:userQuery.toLowerCase(),};let query=newParsedQuery(userQuery);try{parseInput(query,parserState);if(parserState.typeFilter!==null){let typeFilter=parserState.typeFilter;if(typeFilter==="const"){typeFilter="constant"}query.typeFilter=itemTypeFromName(typeFilter)}}catch(err){query=newParsedQuery(userQuery);query.error=err.message;query.typeFilter=-1;return query}if(!query.literalSearch){query.literalSearch=parserState.totalElems>1}query.foundElems=query.elems.length+query.returned.length;return query}function createQueryResults(results_in_args,results_returned,results_others,parsedQuery){return{"in_args":results_in_args,"returned":results_returned,"others":results_others,"query":parsedQuery,}}function execQuery(parsedQuery,searchWords,filterCrates,currentCrate){const results_others={},results_in_args={},results_returned={};function transformResults(results){const duplicates={};const out=[];for(const result of results){if(result.id>-1){const obj=searchIndex[result.id];obj.lev=result.lev;const res=buildHrefAndPath(obj);obj.displayPath=pathSplitter(res[0]);obj.fullPath=obj.displayPath+obj.name;obj.fullPath+="|"+obj.ty;if(duplicates[obj.fullPath]){continue}duplicates[obj.fullPath]=true;obj.href=res[1];out.push(obj);if(out.length>=MAX_RESULTS){break}}}return out}function sortResults(results,isType,preferredCrate){const userQuery=parsedQuery.userQuery;const ar=[];for(const entry in results){if(hasOwnPropertyRustdoc(results,entry)){const result=results[entry];result.word=searchWords[result.id];result.item=searchIndex[result.id]||{};ar.push(result)}}results=ar;if(results.length===0){return[]}results.sort((aaa,bbb)=>{let a,b;a=(aaa.word!==userQuery);b=(bbb.word!==userQuery);if(a!==b){return a-b}a=(aaa.lev);b=(bbb.lev);if(a!==b){return a-b}a=(aaa.item.crate!==preferredCrate);b=(bbb.item.crate!==preferredCrate);if(a!==b){return a-b}a=aaa.word.length;b=bbb.word.length;if(a!==b){return a-b}a=aaa.word;b=bbb.word;if(a!==b){return(a>b?+1:-1)}a=(aaa.index<0);b=(bbb.index<0);if(a!==b){return a-b}a=aaa.index;b=bbb.index;if(a!==b){return a-b}if((aaa.item.ty===TY_PRIMITIVE&&bbb.item.ty!==TY_KEYWORD)||(aaa.item.ty===TY_KEYWORD&&bbb.item.ty!==TY_PRIMITIVE)){return-1}if((bbb.item.ty===TY_PRIMITIVE&&aaa.item.ty!==TY_PRIMITIVE)||(bbb.item.ty===TY_KEYWORD&&aaa.item.ty!==TY_KEYWORD)){return 1}a=(aaa.item.desc==="");b=(bbb.item.desc==="");if(a!==b){return a-b}a=aaa.item.ty;b=bbb.item.ty;if(a!==b){return a-b}a=aaa.item.path;b=bbb.item.path;if(a!==b){return(a>b?+1:-1)}return 0});let nameSplit=null;if(parsedQuery.elems.length===1){const hasPath=typeof parsedQuery.elems[0].path==="undefined";nameSplit=hasPath?null:parsedQuery.elems[0].path}for(const result of results){if(result.dontValidate){continue}const name=result.item.name.toLowerCase(),path=result.item.path.toLowerCase(),parent=result.item.parent;if(!isType&&!validateResult(name,path,nameSplit,parent)){result.id=-1}}return transformResults(results)}function checkGenerics(row,elem,defaultLev){if(row.generics.length===0){return elem.generics.length===0?defaultLev:MAX_LEV_DISTANCE+1}else if(row.generics.length>0&&row.generics[0].name===null){return checkGenerics(row.generics[0],elem,defaultLev)}let elem_name;if(elem.generics.length>0&&row.generics.length>=elem.generics.length){const elems=Object.create(null);for(const entry of row.generics){elem_name=entry.name;if(elem_name===""){if(checkGenerics(entry,elem,MAX_LEV_DISTANCE+1)!==0){return MAX_LEV_DISTANCE+1}continue}if(elems[elem_name]===undefined){elems[elem_name]=0}elems[elem_name]+=1}for(const generic of elem.generics){let match=null;if(elems[generic.name]){match=generic.name}else{for(elem_name in elems){if(!hasOwnPropertyRustdoc(elems,elem_name)){continue}if(elem_name===generic){match=elem_name;break}}}if(match===null){return MAX_LEV_DISTANCE+1}elems[match]-=1;if(elems[match]===0){delete elems[match]}}return 0}return MAX_LEV_DISTANCE+1}function checkIfInGenerics(row,elem){let lev=MAX_LEV_DISTANCE+1;for(const entry of row.generics){lev=Math.min(checkType(entry,elem,true),lev);if(lev===0){break}}return lev}function checkType(row,elem,literalSearch){if(row.name===null){if(row.generics.length>0){return checkIfInGenerics(row,elem)}return MAX_LEV_DISTANCE+1}let lev=levenshtein(row.name,elem.name);if(literalSearch){if(lev!==0){if(elem.generics.length===0){const checkGeneric=row.generics.length>0;if(checkGeneric&&row.generics.findIndex(tmp_elem=>tmp_elem.name===elem.name)!==-1){return 0}}return MAX_LEV_DISTANCE+1}else if(elem.generics.length>0){return checkGenerics(row,elem,MAX_LEV_DISTANCE+1)}return 0}else if(row.generics.length>0){if(elem.generics.length===0){if(lev===0){return 0}lev=checkIfInGenerics(row,elem);return lev+0.5}else if(lev>MAX_LEV_DISTANCE){return checkIfInGenerics(row,elem)}else{const tmp_lev=checkGenerics(row,elem,lev);if(tmp_lev>MAX_LEV_DISTANCE){return MAX_LEV_DISTANCE+1}return(tmp_lev+lev)/2}}else if(elem.generics.length>0){return MAX_LEV_DISTANCE+1}return lev}function findArg(row,elem,typeFilter){let lev=MAX_LEV_DISTANCE+1;if(row&&row.type&&row.type.inputs&&row.type.inputs.length>0){for(const input of row.type.inputs){if(!typePassesFilter(typeFilter,input.ty)){continue}lev=Math.min(lev,checkType(input,elem,parsedQuery.literalSearch));if(lev===0){return 0}}}return parsedQuery.literalSearch?MAX_LEV_DISTANCE+1:lev}function checkReturned(row,elem,typeFilter){let lev=MAX_LEV_DISTANCE+1;if(row&&row.type&&row.type.output.length>0){const ret=row.type.output;for(const ret_ty of ret){if(!typePassesFilter(typeFilter,ret_ty.ty)){continue}lev=Math.min(lev,checkType(ret_ty,elem,parsedQuery.literalSearch));if(lev===0){return 0}}}return parsedQuery.literalSearch?MAX_LEV_DISTANCE+1:lev}function checkPath(contains,ty){if(contains.length===0){return 0}let ret_lev=MAX_LEV_DISTANCE+1;const path=ty.path.split("::");if(ty.parent&&ty.parent.name){path.push(ty.parent.name.toLowerCase())}const length=path.length;const clength=contains.length;if(clength>length){return MAX_LEV_DISTANCE+1}for(let i=0;ilength){break}let lev_total=0;let aborted=false;for(let x=0;xMAX_LEV_DISTANCE){aborted=true;break}lev_total+=lev}if(!aborted){ret_lev=Math.min(ret_lev,Math.round(lev_total/clength))}}return ret_lev}function typePassesFilter(filter,type){if(filter<=NO_TYPE_FILTER||filter===type)return true;const name=itemTypes[type];switch(itemTypes[filter]){case"constant":return name==="associatedconstant";case"fn":return name==="method"||name==="tymethod";case"type":return name==="primitive"||name==="associatedtype";case"trait":return name==="traitalias"}return false}function createAliasFromItem(item){return{crate:item.crate,name:item.name,path:item.path,desc:item.desc,ty:item.ty,parent:item.parent,type:item.type,is_alias:true,}}function handleAliases(ret,query,filterCrates,currentCrate){const lowerQuery=query.toLowerCase();const aliases=[];const crateAliases=[];if(filterCrates!==null){if(ALIASES[filterCrates]&&ALIASES[filterCrates][lowerQuery]){const query_aliases=ALIASES[filterCrates][lowerQuery];for(const alias of query_aliases){aliases.push(createAliasFromItem(searchIndex[alias]))}}}else{Object.keys(ALIASES).forEach(crate=>{if(ALIASES[crate][lowerQuery]){const pushTo=crate===currentCrate?crateAliases:aliases;const query_aliases=ALIASES[crate][lowerQuery];for(const alias of query_aliases){pushTo.push(createAliasFromItem(searchIndex[alias]))}}})}const sortFunc=(aaa,bbb)=>{if(aaa.path{alias.alias=query;const res=buildHrefAndPath(alias);alias.displayPath=pathSplitter(res[0]);alias.fullPath=alias.displayPath+alias.name;alias.href=res[1];ret.others.unshift(alias);if(ret.others.length>MAX_RESULTS){ret.others.pop()}};aliases.forEach(pushFunc);crateAliases.forEach(pushFunc)}function addIntoResults(results,fullId,id,index,lev){if(lev===0||(!parsedQuery.literalSearch&&lev<=MAX_LEV_DISTANCE)){if(results[fullId]!==undefined){const result=results[fullId];if(result.dontValidate||result.lev<=lev){return}}results[fullId]={id:id,index:index,dontValidate:parsedQuery.literalSearch,lev:lev,}}}function handleSingleArg(row,pos,elem,results_others,results_in_args,results_returned){if(!row||(filterCrates!==null&&row.crate!==filterCrates)){return}let lev,lev_add=0,index=-1;const fullId=row.id;const in_args=findArg(row,elem,parsedQuery.typeFilter);const returned=checkReturned(row,elem,parsedQuery.typeFilter);addIntoResults(results_in_args,fullId,pos,index,in_args);addIntoResults(results_returned,fullId,pos,index,returned);if(!typePassesFilter(parsedQuery.typeFilter,row.ty)){return}const searchWord=searchWords[pos];if(parsedQuery.literalSearch){if(searchWord===elem.name){addIntoResults(results_others,fullId,pos,-1,0)}return}if(elem.name.length===0){if(row.type!==null){lev=checkGenerics(row.type,elem,MAX_LEV_DISTANCE+1);addIntoResults(results_others,fullId,pos,index,lev)}return}if(elem.fullPath.length>1){lev=checkPath(elem.pathWithoutLast,row);if(lev>MAX_LEV_DISTANCE||(parsedQuery.literalSearch&&lev!==0)){return}else if(lev>0){lev_add=lev/10}}if(searchWord.indexOf(elem.pathLast)>-1||row.normalizedName.indexOf(elem.pathLast)>-1){index=row.normalizedName.indexOf(elem.pathLast)}lev=levenshtein(searchWord,elem.pathLast);if(lev>0&&elem.pathLast.length>2&&searchWord.indexOf(elem.pathLast)>-1){if(elem.pathLast.length<6){lev=1}else{lev=0}}lev+=lev_add;if(lev>MAX_LEV_DISTANCE){return}else if(index!==-1&&elem.fullPath.length<2){lev-=1}if(lev<0){lev=0}addIntoResults(results_others,fullId,pos,index,lev)}function handleArgs(row,pos,results){if(!row||(filterCrates!==null&&row.crate!==filterCrates)){return}let totalLev=0;let nbLev=0;function checkArgs(elems,callback){for(const elem of elems){const lev=callback(row,elem,NO_TYPE_FILTER);if(lev<=1){nbLev+=1;totalLev+=lev}else{return false}}return true}if(!checkArgs(parsedQuery.elems,findArg)){return}if(!checkArgs(parsedQuery.returned,checkReturned)){return}if(nbLev===0){return}const lev=Math.round(totalLev/nbLev);addIntoResults(results,row.id,pos,0,lev)}function innerRunQuery(){let elem,i,nSearchWords,in_returned,row;if(parsedQuery.foundElems===1){if(parsedQuery.elems.length===1){elem=parsedQuery.elems[0];for(i=0,nSearchWords=searchWords.length;i0){for(i=0,nSearchWords=searchWords.length;i-1||path.indexOf(key)>-1||(parent!==undefined&&parent.name!==undefined&&parent.name.toLowerCase().indexOf(key)>-1)||levenshtein(name,key)<=MAX_LEV_DISTANCE)){return false}}return true}function nextTab(direction){const next=(searchState.currentTab+direction+3)%searchState.focusedByTab.length;searchState.focusedByTab[searchState.currentTab]=document.activeElement;printTab(next);focusSearchResult()}function focusSearchResult(){const target=searchState.focusedByTab[searchState.currentTab]||document.querySelectorAll(".search-results.active a").item(0)||document.querySelectorAll("#titles > button").item(searchState.currentTab);if(target){target.focus()}}function buildHrefAndPath(item){let displayPath;let href;const type=itemTypes[item.ty];const name=item.name;let path=item.path;if(type==="mod"){displayPath=path+"::";href=ROOT_PATH+path.replace(/::/g,"/")+"/"+name+"/index.html"}else if(type==="import"){displayPath=item.path+"::";href=ROOT_PATH+item.path.replace(/::/g,"/")+"/index.html#reexport."+name}else if(type==="primitive"||type==="keyword"){displayPath="";href=ROOT_PATH+path.replace(/::/g,"/")+"/"+type+"."+name+".html"}else if(type==="externcrate"){displayPath="";href=ROOT_PATH+name+"/index.html"}else if(item.parent!==undefined){const myparent=item.parent;let anchor="#"+type+"."+name;const parentType=itemTypes[myparent.ty];let pageType=parentType;let pageName=myparent.name;if(parentType==="primitive"){displayPath=myparent.name+"::"}else if(type==="structfield"&&parentType==="variant"){const enumNameIdx=item.path.lastIndexOf("::");const enumName=item.path.substr(enumNameIdx+2);path=item.path.substr(0,enumNameIdx);displayPath=path+"::"+enumName+"::"+myparent.name+"::";anchor="#variant."+myparent.name+".field."+name;pageType="enum";pageName=enumName}else{displayPath=path+"::"+myparent.name+"::"}href=ROOT_PATH+path.replace(/::/g,"/")+"/"+pageType+"."+pageName+".html"+anchor}else{displayPath=item.path+"::";href=ROOT_PATH+item.path.replace(/::/g,"/")+"/"+type+"."+name+".html"}return[displayPath,href]}function escape(content){const h1=document.createElement("h1");h1.textContent=content;return h1.innerHTML}function pathSplitter(path){const tmp=""+path.replace(/::/g,"::");if(tmp.endsWith("")){return tmp.slice(0,tmp.length-6)}return tmp}function addTab(array,query,display){let extraClass="";if(display===true){extraClass=" active"}const output=document.createElement("div");let length=0;if(array.length>0){output.className="search-results "+extraClass;array.forEach(item=>{const name=item.name;const type=itemTypes[item.ty];length+=1;let extra="";if(type==="primitive"){extra=" (primitive type)"}else if(type==="keyword"){extra=" (keyword)"}const link=document.createElement("a");link.className="result-"+type;link.href=item.href;const wrapper=document.createElement("div");const resultName=document.createElement("div");resultName.className="result-name";if(item.is_alias){const alias=document.createElement("span");alias.className="alias";const bold=document.createElement("b");bold.innerText=item.alias;alias.appendChild(bold);alias.insertAdjacentHTML("beforeend"," - see ");resultName.appendChild(alias)}resultName.insertAdjacentHTML("beforeend",item.displayPath+""+name+extra+"");wrapper.appendChild(resultName);const description=document.createElement("div");description.className="desc";const spanDesc=document.createElement("span");spanDesc.insertAdjacentHTML("beforeend",item.desc);description.appendChild(spanDesc);wrapper.appendChild(description);link.appendChild(wrapper);output.appendChild(link)})}else if(query.error===null){output.className="search-failed"+extraClass;output.innerHTML="No results :(
    "+"Try on DuckDuckGo?

    "+"Or try looking in one of these:"}return[output,length]}function makeTabHeader(tabNb,text,nbElems){if(searchState.currentTab===tabNb){return""}return""}function showResults(results,go_to_first,filterCrates){const search=searchState.outputElement();if(go_to_first||(results.others.length===1&&getSettingValue("go-to-only-result")==="true"&&(!search.firstChild||search.firstChild.innerText!==searchState.loadingText))){const elem=document.createElement("a");elem.href=results.others[0].href;removeClass(elem,"active");document.body.appendChild(elem);elem.click();return}if(results.query===undefined){results.query=parseQuery(searchState.input.value)}currentResults=results.query.userQuery;const ret_others=addTab(results.others,results.query,true);const ret_in_args=addTab(results.in_args,results.query,false);const ret_returned=addTab(results.returned,results.query,false);let currentTab=searchState.currentTab;if((currentTab===0&&ret_others[1]===0)||(currentTab===1&&ret_in_args[1]===0)||(currentTab===2&&ret_returned[1]===0)){if(ret_others[1]!==0){currentTab=0}else if(ret_in_args[1]!==0){currentTab=1}else if(ret_returned[1]!==0){currentTab=2}}let crates="";const crates_list=Object.keys(rawSearchIndex);if(crates_list.length>1){crates=" in "}let typeFilter="";if(results.query.typeFilter!==NO_TYPE_FILTER){typeFilter=" (type: "+escape(itemTypes[results.query.typeFilter])+")"}let output="
    "+`

    Results for ${escape(results.query.userQuery)}`+`${typeFilter}

    ${crates}
    `;if(results.query.error!==null){output+=`

    Query parser error: "${results.query.error}".

    `;output+="
    "+makeTabHeader(0,"In Names",ret_others[1])+"
    ";currentTab=0}else if(results.query.foundElems<=1&&results.query.returned.length===0){output+="
    "+makeTabHeader(0,"In Names",ret_others[1])+makeTabHeader(1,"In Parameters",ret_in_args[1])+makeTabHeader(2,"In Return Types",ret_returned[1])+"
    "}else{const signatureTabTitle=results.query.elems.length===0?"In Function Return Types":results.query.returned.length===0?"In Function Parameters":"In Function Signatures";output+="
    "+makeTabHeader(0,signatureTabTitle,ret_others[1])+"
    ";currentTab=0}const resultsElem=document.createElement("div");resultsElem.id="results";resultsElem.appendChild(ret_others[0]);resultsElem.appendChild(ret_in_args[0]);resultsElem.appendChild(ret_returned[0]);search.innerHTML=output;const crateSearch=document.getElementById("crate-search");if(crateSearch){crateSearch.addEventListener("input",updateCrate)}search.appendChild(resultsElem);searchState.showResults(search);const elems=document.getElementById("titles").childNodes;searchState.focusedByTab=[];let i=0;for(const elem of elems){const j=i;elem.onclick=()=>printTab(j);searchState.focusedByTab.push(null);i+=1}printTab(currentTab)}function search(e,forced){const params=searchState.getQueryStringParams();const query=parseQuery(searchState.input.value.trim());if(e){e.preventDefault()}if(!forced&&query.userQuery===currentResults){if(query.userQuery.length>0){putBackSearch()}return}let filterCrates=getFilterCrates();if(filterCrates===null&¶ms["filter-crate"]!==undefined){filterCrates=params["filter-crate"]}searchState.title="Results for "+query.original+" - Rust";if(browserSupportsHistoryApi()){const newURL=buildUrl(query.original,filterCrates);if(!history.state&&!params.search){history.pushState(null,"",newURL)}else{history.replaceState(null,"",newURL)}}showResults(execQuery(query,searchWords,filterCrates,window.currentCrate),params.go_to_first,filterCrates)}function buildItemSearchTypeAll(types,lowercasePaths){const PATH_INDEX_DATA=0;const GENERICS_DATA=1;return types.map(type=>{let pathIndex,generics;if(typeof type==="number"){pathIndex=type;generics=[]}else{pathIndex=type[PATH_INDEX_DATA];generics=buildItemSearchTypeAll(type[GENERICS_DATA],lowercasePaths)}return{name:pathIndex===0?null:lowercasePaths[pathIndex-1].name,ty:pathIndex===0?null:lowercasePaths[pathIndex-1].ty,generics:generics,}})}function buildFunctionSearchType(functionSearchType,lowercasePaths){const INPUTS_DATA=0;const OUTPUT_DATA=1;if(functionSearchType===0){return null}let inputs,output;if(typeof functionSearchType[INPUTS_DATA]==="number"){const pathIndex=functionSearchType[INPUTS_DATA];inputs=[{name:pathIndex===0?null:lowercasePaths[pathIndex-1].name,ty:pathIndex===0?null:lowercasePaths[pathIndex-1].ty,generics:[],}]}else{inputs=buildItemSearchTypeAll(functionSearchType[INPUTS_DATA],lowercasePaths)}if(functionSearchType.length>1){if(typeof functionSearchType[OUTPUT_DATA]==="number"){const pathIndex=functionSearchType[OUTPUT_DATA];output=[{name:pathIndex===0?null:lowercasePaths[pathIndex-1].name,ty:pathIndex===0?null:lowercasePaths[pathIndex-1].ty,generics:[],}]}else{output=buildItemSearchTypeAll(functionSearchType[OUTPUT_DATA],lowercasePaths)}}else{output=[]}return{inputs,output,}}function buildIndex(rawSearchIndex){searchIndex=[];const searchWords=[];let i,word;let currentIndex=0;let id=0;for(const crate in rawSearchIndex){if(!hasOwnPropertyRustdoc(rawSearchIndex,crate)){continue}let crateSize=0;const crateCorpus=rawSearchIndex[crate];searchWords.push(crate);const crateRow={crate:crate,ty:1,name:crate,path:"",desc:crateCorpus.doc,parent:undefined,type:null,id:id,normalizedName:crate.indexOf("_")===-1?crate:crate.replace(/_/g,""),};id+=1;searchIndex.push(crateRow);currentIndex+=1;const itemTypes=crateCorpus.t;const itemNames=crateCorpus.n;const itemPaths=crateCorpus.q;const itemDescs=crateCorpus.d;const itemParentIdxs=crateCorpus.i;const itemFunctionSearchTypes=crateCorpus.f;const paths=crateCorpus.p;const aliases=crateCorpus.a;const lowercasePaths=[];let len=paths.length;for(i=0;i0?paths[itemParentIdxs[i]-1]:undefined,type:buildFunctionSearchType(itemFunctionSearchTypes[i],lowercasePaths),id:id,normalizedName:word.indexOf("_")===-1?word:word.replace(/_/g,""),};id+=1;searchIndex.push(row);lastPath=row.path;crateSize+=1}if(aliases){ALIASES[crate]=Object.create(null);for(const alias_name in aliases){if(!hasOwnPropertyRustdoc(aliases,alias_name)){continue}if(!hasOwnPropertyRustdoc(ALIASES[crate],alias_name)){ALIASES[crate][alias_name]=[]}for(const local_alias of aliases[alias_name]){ALIASES[crate][alias_name].push(local_alias+currentIndex)}}}currentIndex+=crateSize}return searchWords}function onSearchSubmit(e){e.preventDefault();searchState.clearInputTimeout();search()}function putBackSearch(){const search_input=searchState.input;if(!searchState.input){return}if(search_input.value!==""&&!searchState.isDisplayed()){searchState.showResults();if(browserSupportsHistoryApi()){history.replaceState(null,"",buildUrl(search_input.value,getFilterCrates()))}document.title=searchState.title}}function registerSearchEvents(){const params=searchState.getQueryStringParams();if(searchState.input.value===""){searchState.input.value=params.search||""}const searchAfter500ms=()=>{searchState.clearInputTimeout();if(searchState.input.value.length===0){if(browserSupportsHistoryApi()){history.replaceState(null,window.currentCrate+" - Rust",getNakedUrl()+window.location.hash)}searchState.hideResults()}else{searchState.timeout=setTimeout(search,500)}};searchState.input.onkeyup=searchAfter500ms;searchState.input.oninput=searchAfter500ms;document.getElementsByClassName("search-form")[0].onsubmit=onSearchSubmit;searchState.input.onchange=e=>{if(e.target!==document.activeElement){return}searchState.clearInputTimeout();setTimeout(search,0)};searchState.input.onpaste=searchState.input.onchange;searchState.outputElement().addEventListener("keydown",e=>{if(e.altKey||e.ctrlKey||e.shiftKey||e.metaKey){return}if(e.which===38){const previous=document.activeElement.previousElementSibling;if(previous){previous.focus()}else{searchState.focus()}e.preventDefault()}else if(e.which===40){const next=document.activeElement.nextElementSibling;if(next){next.focus()}const rect=document.activeElement.getBoundingClientRect();if(window.innerHeight-rect.bottom{if(e.which===40){focusSearchResult();e.preventDefault()}});searchState.input.addEventListener("focus",()=>{putBackSearch()});searchState.input.addEventListener("blur",()=>{searchState.input.placeholder=searchState.input.origPlaceholder});if(browserSupportsHistoryApi()){const previousTitle=document.title;window.addEventListener("popstate",e=>{const params=searchState.getQueryStringParams();document.title=previousTitle;currentResults=null;if(params.search&¶ms.search.length>0){searchState.input.value=params.search;search(e)}else{searchState.input.value="";searchState.hideResults()}})}window.onpageshow=()=>{const qSearch=searchState.getQueryStringParams().search;if(searchState.input.value===""&&qSearch){searchState.input.value=qSearch}search()}}function updateCrate(ev){if(ev.target.value==="All crates"){const params=searchState.getQueryStringParams();const query=searchState.input.value.trim();if(!history.state&&!params.search){history.pushState(null,"",buildUrl(query,null))}else{history.replaceState(null,"",buildUrl(query,null))}}currentResults=null;search(undefined,true)}const searchWords=buildIndex(rawSearchIndex);if(typeof window!=="undefined"){registerSearchEvents();if(window.searchState.getQueryStringParams().search){search()}}if(typeof exports!=="undefined"){exports.initSearch=initSearch;exports.execQuery=execQuery;exports.parseQuery=parseQuery}return searchWords}if(typeof window!=="undefined"){window.initSearch=initSearch;if(window.searchIndex!==undefined){initSearch(window.searchIndex)}}else{initSearch({})}})() \ No newline at end of file diff --git a/ch5/settings.css b/ch5/settings.css deleted file mode 100644 index a142e14f..00000000 --- a/ch5/settings.css +++ /dev/null @@ -1 +0,0 @@ -.setting-line{margin:0.6em 0 0.6em 0.3em;position:relative;}.setting-line .choices{display:flex;flex-wrap:wrap;}.setting-line .radio-line input{margin-right:0.3em;height:1.2rem;width:1.2rem;border:1px solid;outline:none;-webkit-appearance:none;cursor:pointer;border-radius:50%;}.setting-line .radio-line input+span{padding-bottom:1px;}.radio-line .setting-name{width:100%;}.radio-line .choice{margin-top:0.1em;margin-bottom:0.1em;min-width:3.8em;padding:0.3em;display:flex;align-items:center;cursor:pointer;}.radio-line .choice+.choice{margin-left:0.5em;}.toggle{position:relative;width:100%;margin-right:20px;display:flex;align-items:center;cursor:pointer;}.toggle input{opacity:0;position:absolute;}.slider{position:relative;width:45px;min-width:45px;display:block;height:28px;margin-right:20px;cursor:pointer;background-color:#ccc;transition:.3s;}.slider:before{position:absolute;content:"";height:19px;width:19px;left:4px;bottom:4px;transition:.3s;}input:checked+.slider:before{transform:translateX(19px);}.setting-line>.sub-settings{padding-left:42px;width:100%;display:block;}#settings .setting-line{margin:1.2em 0.6em;} \ No newline at end of file diff --git a/ch5/settings.html b/ch5/settings.html index ecb27c50..44145da1 100644 --- a/ch5/settings.html +++ b/ch5/settings.html @@ -1 +1 @@ -Rustdoc settings

    Rustdoc settings

    Back
    \ No newline at end of file +Rustdoc settings

    Rustdoc settings

    Back
    \ No newline at end of file diff --git a/ch5/settings.js b/ch5/settings.js deleted file mode 100644 index df27fca4..00000000 --- a/ch5/settings.js +++ /dev/null @@ -1,11 +0,0 @@ -"use strict";(function(){const isSettingsPage=window.location.pathname.endsWith("/settings.html");function changeSetting(settingName,value){updateLocalStorage(settingName,value);switch(settingName){case"theme":case"preferred-dark-theme":case"preferred-light-theme":case"use-system-theme":updateSystemTheme();updateLightAndDark();break}}function handleKey(ev){if(ev.ctrlKey||ev.altKey||ev.metaKey){return}switch(getVirtualKey(ev)){case"Enter":case"Return":case"Space":ev.target.checked=!ev.target.checked;ev.preventDefault();break}}function showLightAndDark(){addClass(document.getElementById("theme").parentElement,"hidden");removeClass(document.getElementById("preferred-light-theme").parentElement,"hidden");removeClass(document.getElementById("preferred-dark-theme").parentElement,"hidden")}function hideLightAndDark(){addClass(document.getElementById("preferred-light-theme").parentElement,"hidden");addClass(document.getElementById("preferred-dark-theme").parentElement,"hidden");removeClass(document.getElementById("theme").parentElement,"hidden")}function updateLightAndDark(){if(getSettingValue("use-system-theme")!=="false"){showLightAndDark()}else{hideLightAndDark()}}function setEvents(settingsElement){updateLightAndDark();onEachLazy(settingsElement.getElementsByClassName("slider"),elem=>{const toggle=elem.previousElementSibling;const settingId=toggle.id;const settingValue=getSettingValue(settingId);if(settingValue!==null){toggle.checked=settingValue==="true"}toggle.onchange=function(){changeSetting(this.id,this.checked)};toggle.onkeyup=handleKey;toggle.onkeyrelease=handleKey});onEachLazy(settingsElement.getElementsByClassName("select-wrapper"),elem=>{const select=elem.getElementsByTagName("select")[0];const settingId=select.id;const settingValue=getSettingValue(settingId);if(settingValue!==null){select.value=settingValue}select.onchange=function(){changeSetting(this.id,this.value)}});onEachLazy(settingsElement.querySelectorAll("input[type=\"radio\"]"),elem=>{const settingId=elem.name;const settingValue=getSettingValue(settingId);if(settingValue!==null&&settingValue!=="null"){elem.checked=settingValue===elem.value}elem.addEventListener("change",ev=>{changeSetting(ev.target.name,ev.target.value)})})}function buildSettingsPageSections(settings){let output="";for(const setting of settings){output+="
    ";const js_data_name=setting["js_name"];const setting_name=setting["name"];if(setting["options"]!==undefined){output+=`
    \ - ${setting_name}\ -
    `;onEach(setting["options"],option=>{const checked=option===setting["default"]?" checked":"";output+=``});output+="
    "}else{const checked=setting["default"]===true?" checked":"";output+=``}output+="
    "}return output}function buildSettingsPage(){const themes=getVar("themes").split(",");const settings=[{"name":"Use system theme","js_name":"use-system-theme","default":true,},{"name":"Theme","js_name":"theme","default":"light","options":themes,},{"name":"Preferred light theme","js_name":"preferred-light-theme","default":"light","options":themes,},{"name":"Preferred dark theme","js_name":"preferred-dark-theme","default":"dark","options":themes,},{"name":"Auto-hide item contents for large items","js_name":"auto-hide-large-items","default":true,},{"name":"Auto-hide item methods' documentation","js_name":"auto-hide-method-docs","default":false,},{"name":"Auto-hide trait implementation documentation","js_name":"auto-hide-trait-implementations","default":false,},{"name":"Directly go to item in search if there is only one result","js_name":"go-to-only-result","default":false,},{"name":"Show line numbers on code examples","js_name":"line-numbers","default":false,},{"name":"Disable keyboard shortcuts","js_name":"disable-shortcuts","default":false,},];const elementKind=isSettingsPage?"section":"div";const innerHTML=`
    ${buildSettingsPageSections(settings)}
    `;const el=document.createElement(elementKind);el.id="settings";el.className="popover";el.innerHTML=innerHTML;if(isSettingsPage){document.getElementById(MAIN_ID).appendChild(el)}else{el.setAttribute("tabindex","-1");getSettingsButton().appendChild(el)}return el}const settingsMenu=buildSettingsPage();function displaySettings(){settingsMenu.style.display=""}function settingsBlurHandler(event){blurHandler(event,getSettingsButton(),window.hidePopoverMenus)}if(isSettingsPage){getSettingsButton().onclick=function(event){event.preventDefault()}}else{const settingsButton=getSettingsButton();const settingsMenu=document.getElementById("settings");settingsButton.onclick=function(event){if(elemIsInParent(event.target,settingsMenu)){return}event.preventDefault();const shouldDisplaySettings=settingsMenu.style.display==="none";window.hidePopoverMenus();if(shouldDisplaySettings){displaySettings()}};settingsButton.onblur=settingsBlurHandler;settingsButton.querySelector("a").onblur=settingsBlurHandler;onEachLazy(settingsMenu.querySelectorAll("input"),el=>{el.onblur=settingsBlurHandler});settingsMenu.onblur=settingsBlurHandler}setTimeout(()=>{setEvents(settingsMenu);if(!isSettingsPage){displaySettings()}removeClass(getSettingsButton(),"rotate")},0)})() \ No newline at end of file diff --git a/ch5/source-script.js b/ch5/source-script.js deleted file mode 100644 index e0fac073..00000000 --- a/ch5/source-script.js +++ /dev/null @@ -1 +0,0 @@ -"use strict";(function(){const rootPath=document.getElementById("rustdoc-vars").attributes["data-root-path"].value;let oldScrollPosition=0;const NAME_OFFSET=0;const DIRS_OFFSET=1;const FILES_OFFSET=2;function closeSidebarIfMobile(){if(window.innerWidth"){if(window.innerWidth";updateLocalStorage("source-sidebar-show","false")}}function createSidebarToggle(){const sidebarToggle=document.createElement("div");sidebarToggle.id="sidebar-toggle";const inner=document.createElement("button");if(getCurrentValue("source-sidebar-show")==="true"){inner.innerText="<"}else{inner.innerText=">"}inner.onclick=toggleSidebar;sidebarToggle.appendChild(inner);return sidebarToggle}function createSourceSidebar(){const container=document.querySelector("nav.sidebar");const sidebarToggle=createSidebarToggle();container.insertBefore(sidebarToggle,container.firstChild);const sidebar=document.createElement("div");sidebar.id="source-sidebar";let hasFoundFile=false;const title=document.createElement("div");title.className="title";title.innerText="Files";sidebar.appendChild(title);Object.keys(sourcesIndex).forEach(key=>{sourcesIndex[key][NAME_OFFSET]=key;hasFoundFile=createDirEntry(sourcesIndex[key],sidebar,"",hasFoundFile)});container.appendChild(sidebar);const selected_elem=sidebar.getElementsByClassName("selected")[0];if(typeof selected_elem!=="undefined"){selected_elem.focus()}}const lineNumbersRegex=/^#?(\d+)(?:-(\d+))?$/;function highlightSourceLines(match){if(typeof match==="undefined"){match=window.location.hash.match(lineNumbersRegex)}if(!match){return}let from=parseInt(match[1],10);let to=from;if(typeof match[2]!=="undefined"){to=parseInt(match[2],10)}if(to{onEachLazy(e.getElementsByTagName("span"),i_e=>{removeClass(i_e,"line-highlighted")})});for(let i=from;i<=to;++i){elem=document.getElementById(i);if(!elem){break}addClass(elem,"line-highlighted")}}const handleSourceHighlight=(function(){let prev_line_id=0;const set_fragment=name=>{const x=window.scrollX,y=window.scrollY;if(browserSupportsHistoryApi()){history.replaceState(null,null,"#"+name);highlightSourceLines()}else{location.replace("#"+name)}window.scrollTo(x,y)};return ev=>{let cur_line_id=parseInt(ev.target.id,10);if(isNaN(cur_line_id)){return}ev.preventDefault();if(ev.shiftKey&&prev_line_id){if(prev_line_id>cur_line_id){const tmp=prev_line_id;prev_line_id=cur_line_id;cur_line_id=tmp}set_fragment(prev_line_id+"-"+cur_line_id)}else{prev_line_id=cur_line_id;set_fragment(cur_line_id)}}}());window.addEventListener("hashchange",()=>{const match=window.location.hash.match(lineNumbersRegex);if(match){return highlightSourceLines(match)}});onEachLazy(document.getElementsByClassName("line-numbers"),el=>{el.addEventListener("click",handleSourceHighlight)});highlightSourceLines();window.createSourceSidebar=createSourceSidebar})() \ No newline at end of file diff --git a/ch5/source-files.js b/ch5/src-files.js similarity index 88% rename from ch5/source-files.js rename to ch5/src-files.js index 5704744f..ed981ad2 100644 --- a/ch5/source-files.js +++ b/ch5/src-files.js @@ -1,4 +1,4 @@ -var sourcesIndex = JSON.parse('{\ +var srcIndex = JSON.parse('{\ "os":["",[["boards",[],["qemu.rs"]],["mm",[],["address.rs","frame_allocator.rs","heap_allocator.rs","memory_set.rs","mod.rs","page_table.rs"]],["sync",[],["mod.rs","up.rs"]],["syscall",[],["fs.rs","mod.rs","process.rs"]],["task",[],["context.rs","manager.rs","mod.rs","pid.rs","processor.rs","switch.rs","task.rs"]],["trap",[],["context.rs","mod.rs"]]],["config.rs","console.rs","lang_items.rs","loader.rs","main.rs","sbi.rs","timer.rs"]]\ }'); -createSourceSidebar(); +createSrcSidebar(); diff --git a/ch5/src/os/boards/qemu.rs.html b/ch5/src/os/boards/qemu.rs.html index 178b5814..5c5fbbda 100644 --- a/ch5/src/os/boards/qemu.rs.html +++ b/ch5/src/os/boards/qemu.rs.html @@ -1,18 +1,17 @@ -qemu.rs - source
    1
-2
-3
-4
-5
-6
-7
-8
-
    //! Constants used in rCore for qemu
+qemu.rs - source
    1
+2
+3
+4
+5
+6
+7
+8
+
    //! Constants used in rCore for qemu
 
-pub const CLOCK_FREQ: usize = 12500000;
-pub const MEMORY_END: usize = 0x81000000;
+pub const CLOCK_FREQ: usize = 12500000;
+pub const MEMORY_END: usize = 0x81000000;
 
-pub const MMIO: &[(usize, usize)] = &[
-    (0x0010_0000, 0x00_2000), // VIRT_TEST/RTC  in virt machine
-];
-
    
-
    \ No newline at end of file +pub const MMIO: &[(usize, usize)] = &[ + (0x0010_0000, 0x00_2000), // VIRT_TEST/RTC in virt machine +]; + \ No newline at end of file diff --git a/ch5/src/os/config.rs.html b/ch5/src/os/config.rs.html index 4b18ced4..5fc8e651 100644 --- a/ch5/src/os/config.rs.html +++ b/ch5/src/os/config.rs.html @@ -1,26 +1,25 @@ -config.rs - source
    1
-2
-3
-4
-5
-6
-7
-8
-9
-10
-11
-12
-
    //! Constants used in rCore
-pub const USER_STACK_SIZE: usize = 4096 * 2;
-pub const KERNEL_STACK_SIZE: usize = 4096 * 2;
-pub const KERNEL_HEAP_SIZE: usize = 0x20_0000;
+config.rs - source
    1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+
    //! Constants used in rCore
+pub const USER_STACK_SIZE: usize = 4096 * 2;
+pub const KERNEL_STACK_SIZE: usize = 4096 * 2;
+pub const KERNEL_HEAP_SIZE: usize = 0x20_0000;
 
-pub const PAGE_SIZE: usize = 0x1000;
-pub const PAGE_SIZE_BITS: usize = 0xc;
+pub const PAGE_SIZE: usize = 0x1000;
+pub const PAGE_SIZE_BITS: usize = 0xc;
 
-pub const TRAMPOLINE: usize = usize::MAX - PAGE_SIZE + 1;
-pub const TRAP_CONTEXT: usize = TRAMPOLINE - PAGE_SIZE;
+pub const TRAMPOLINE: usize = usize::MAX - PAGE_SIZE + 1;
+pub const TRAP_CONTEXT: usize = TRAMPOLINE - PAGE_SIZE;
 
-pub use crate::board::{CLOCK_FREQ, MEMORY_END, MMIO};
-
    
-
    \ No newline at end of file +pub use crate::board::{CLOCK_FREQ, MEMORY_END, MMIO}; + \ No newline at end of file diff --git a/ch5/src/os/console.rs.html b/ch5/src/os/console.rs.html index d95c6c36..c1f9f845 100644 --- a/ch5/src/os/console.rs.html +++ b/ch5/src/os/console.rs.html @@ -1,70 +1,69 @@ -console.rs - source
    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
-
    //! SBI console driver, for text output
-use crate::sbi::console_putchar;
-use core::fmt::{self, Write};
+console.rs - source
    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
+
    //! SBI console driver, for text output
+use crate::sbi::console_putchar;
+use core::fmt::{self, Write};
 
-struct Stdout;
+struct Stdout;
 
-impl Write for Stdout {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        for c in s.chars() {
-            console_putchar(c as usize);
+impl Write for Stdout {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        for c in s.chars() {
+            console_putchar(c as usize);
         }
         Ok(())
     }
 }
 
-pub fn print(args: fmt::Arguments) {
-    Stdout.write_fmt(args).unwrap();
+pub fn print(args: fmt::Arguments) {
+    Stdout.write_fmt(args).unwrap();
 }
 
-#[macro_export]
-/// print string macro
-macro_rules! print {
-    ($fmt: literal $(, $($arg: tt)+)?) => {
-        $crate::console::print(format_args!($fmt $(, $($arg)+)?));
+#[macro_export]
+/// print string macro
+macro_rules! print {
+    ($fmt: literal $(, $($arg: tt)+)?) => {
+        $crate::console::print(format_args!($fmt $(, $($arg)+)?));
     }
 }
 
-#[macro_export]
-/// println string macro
-macro_rules! println {
-    ($fmt: literal $(, $($arg: tt)+)?) => {
-        $crate::console::print(format_args!(concat!($fmt, "\n") $(, $($arg)+)?));
+#[macro_export]
+/// println string macro
+macro_rules! println {
+    ($fmt: literal $(, $($arg: tt)+)?) => {
+        $crate::console::print(format_args!(concat!($fmt, "\n") $(, $($arg)+)?));
     }
 }
-
    
-
    \ No newline at end of file + \ No newline at end of file diff --git a/ch5/src/os/lang_items.rs.html b/ch5/src/os/lang_items.rs.html index 1343e5be..5fe215bd 100644 --- a/ch5/src/os/lang_items.rs.html +++ b/ch5/src/os/lang_items.rs.html @@ -1,40 +1,39 @@ -lang_items.rs - source
    1
-2
-3
-4
-5
-6
-7
-8
-9
-10
-11
-12
-13
-14
-15
-16
-17
-18
-19
-
    //! The panic handler
-use crate::sbi::shutdown;
-use core::panic::PanicInfo;
-use log::*;
+lang_items.rs - source
    1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+
    //! The panic handler
+use crate::sbi::shutdown;
+use core::panic::PanicInfo;
+use log::*;
 
-#[panic_handler]
-fn panic(info: &PanicInfo) -> ! {
-    if let Some(location) = info.location() {
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    if let Some(location) = info.location() {
         error!(
             "[kernel] Panicked at {}:{} {}",
-            location.file(),
-            location.line(),
-            info.message().unwrap()
+            location.file(),
+            location.line(),
+            info.message().unwrap()
         );
-    } else {
-        error!("[kernel] Panicked: {}", info.message().unwrap());
+    } else {
+        error!("[kernel] Panicked: {}", info.message().unwrap());
     }
-    shutdown(true)
+    shutdown(true)
 }
-
    
-
    \ No newline at end of file + \ No newline at end of file diff --git a/ch5/src/os/loader.rs.html b/ch5/src/os/loader.rs.html index eb0cb95c..c60bc498 100644 --- a/ch5/src/os/loader.rs.html +++ b/ch5/src/os/loader.rs.html @@ -1,142 +1,141 @@ -loader.rs - source
    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
-
    //! Loading user applications into memory
+loader.rs - source
    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
+
    //! Loading user applications into memory
 
-/// Get the total number of applications.
-use alloc::vec::Vec;
-use lazy_static::*;
-///get app number
-pub fn get_num_app() -> usize {
-    extern "C" {
-        fn _num_app();
+/// Get the total number of applications.
+use alloc::vec::Vec;
+use lazy_static::*;
+///get app number
+pub fn get_num_app() -> usize {
+    extern "C" {
+        fn _num_app();
     }
-    unsafe { (_num_app as usize as *const usize).read_volatile() }
+    unsafe { (_num_app as usize as *const usize).read_volatile() }
 }
-/// get applications data
-pub fn get_app_data(app_id: usize) -> &'static [u8] {
-    extern "C" {
-        fn _num_app();
+/// get applications data
+pub fn get_app_data(app_id: usize) -> &'static [u8] {
+    extern "C" {
+        fn _num_app();
     }
-    let num_app_ptr = _num_app as usize as *const usize;
-    let num_app = get_num_app();
-    let app_start = unsafe { core::slice::from_raw_parts(num_app_ptr.add(1), num_app + 1) };
-    assert!(app_id < num_app);
-    unsafe {
-        core::slice::from_raw_parts(
-            app_start[app_id] as *const u8,
-            app_start[app_id + 1] - app_start[app_id],
+    let num_app_ptr = _num_app as usize as *const usize;
+    let num_app = get_num_app();
+    let app_start = unsafe { core::slice::from_raw_parts(num_app_ptr.add(1), num_app + 1) };
+    assert!(app_id < num_app);
+    unsafe {
+        core::slice::from_raw_parts(
+            app_start[app_id] as *const u8,
+            app_start[app_id + 1] - app_start[app_id],
         )
     }
 }
 
-lazy_static! {
-    ///All of app's name
-    static ref APP_NAMES: Vec<&'static str> = {
-        let num_app = get_num_app();
-        extern "C" {
-            fn _app_names();
+lazy_static! {
+    ///All of app's name
+    static ref APP_NAMES: Vec<&'static str> = {
+        let num_app = get_num_app();
+        extern "C" {
+            fn _app_names();
         }
-        let mut start = _app_names as usize as *const u8;
-        let mut v = Vec::new();
-        unsafe {
-            for _ in 0..num_app {
-                let mut end = start;
-                while end.read_volatile() != b'\0' {
-                    end = end.add(1);
+        let mut start = _app_names as usize as *const u8;
+        let mut v = Vec::new();
+        unsafe {
+            for _ in 0..num_app {
+                let mut end = start;
+                while end.read_volatile() != b'\0' {
+                    end = end.add(1);
                 }
-                let slice = core::slice::from_raw_parts(start, end as usize - start as usize);
-                let str = core::str::from_utf8(slice).unwrap();
-                v.push(str);
-                start = end.add(1);
+                let slice = core::slice::from_raw_parts(start, end as usize - start as usize);
+                let str = core::str::from_utf8(slice).unwrap();
+                v.push(str);
+                start = end.add(1);
             }
         }
-        v
+        v
     };
 }
 
-#[allow(unused)]
-///get app data from name
-pub fn get_app_data_by_name(name: &str) -> Option<&'static [u8]> {
-    let num_app = get_num_app();
-    (0..num_app)
-        .find(|&i| APP_NAMES[i] == name)
-        .map(get_app_data)
+#[allow(unused)]
+///get app data from name
+pub fn get_app_data_by_name(name: &str) -> Option<&'static [u8]> {
+    let num_app = get_num_app();
+    (0..num_app)
+        .find(|&i| APP_NAMES[i] == name)
+        .map(get_app_data)
 }
-///list all apps
-pub fn list_apps() {
+///list all apps
+pub fn list_apps() {
     println!("/**** APPS ****");
-    for app in APP_NAMES.iter() {
-        println!("{}", app);
+    for app in APP_NAMES.iter() {
+        println!("{}", app);
     }
     println!("**************/");
 }
-
    
-
    \ No newline at end of file + \ No newline at end of file diff --git a/ch5/src/os/main.rs.html b/ch5/src/os/main.rs.html index 552958de..dc6fc630 100644 --- a/ch5/src/os/main.rs.html +++ b/ch5/src/os/main.rs.html @@ -1,162 +1,161 @@ -main.rs - source
    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
-
    //! The main module and entrypoint
-//!
-//! Various facilities of the kernels are implemented as submodules. The most
-//! important ones are:
-//!
-//! - [`trap`]: Handles all cases of switching from userspace to the kernel
-//! - [`task`]: Task management
-//! - [`syscall`]: System call handling and implementation
-//! - [`mm`]: Address map using SV39
-//! - [`sync`]:Wrap a static data structure inside it so that we are able to access it without any `unsafe`.
-//!
-//! The operating system also starts in this module. Kernel code starts
-//! executing from `entry.asm`, after which [`rust_main()`] is called to
-//! initialize various pieces of functionality. (See its source code for
-//! details.)
-//!
-//! We then call [`task::run_tasks()`] and for the first time go to
-//! userspace.
+main.rs - source
    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
+
    //! The main module and entrypoint
+//!
+//! Various facilities of the kernels are implemented as submodules. The most
+//! important ones are:
+//!
+//! - [`trap`]: Handles all cases of switching from userspace to the kernel
+//! - [`task`]: Task management
+//! - [`syscall`]: System call handling and implementation
+//! - [`mm`]: Address map using SV39
+//! - [`sync`]:Wrap a static data structure inside it so that we are able to access it without any `unsafe`.
+//!
+//! The operating system also starts in this module. Kernel code starts
+//! executing from `entry.asm`, after which [`rust_main()`] is called to
+//! initialize various pieces of functionality. (See its source code for
+//! details.)
+//!
+//! We then call [`task::run_tasks()`] and for the first time go to
+//! userspace.
 
-#![deny(missing_docs)]
-#![deny(warnings)]
-#![no_std]
-#![no_main]
-#![feature(panic_info_message)]
-#![feature(alloc_error_handler)]
+#![deny(missing_docs)]
+#![deny(warnings)]
+#![no_std]
+#![no_main]
+#![feature(panic_info_message)]
+#![feature(alloc_error_handler)]
 
-extern crate alloc;
+extern crate alloc;
 
-#[macro_use]
-extern crate bitflags;
+#[macro_use]
+extern crate bitflags;
 
-#[path = "boards/qemu.rs"]
-mod board;
+#[path = "boards/qemu.rs"]
+mod board;
 
-#[macro_use]
-mod console;
-mod config;
-mod lang_items;
-mod loader;
-pub mod mm;
-mod sbi;
-pub mod sync;
-pub mod syscall;
-pub mod task;
-mod timer;
-pub mod trap;
+#[macro_use]
+mod console;
+mod config;
+mod lang_items;
+mod loader;
+pub mod mm;
+mod sbi;
+pub mod sync;
+pub mod syscall;
+pub mod task;
+mod timer;
+pub mod trap;
 
-use core::arch::global_asm;
+use core::arch::global_asm;
 
 global_asm!(include_str!("entry.asm"));
 global_asm!(include_str!("link_app.S"));
-/// clear BSS segment
-fn clear_bss() {
-    extern "C" {
-        fn sbss();
-        fn ebss();
+/// clear BSS segment
+fn clear_bss() {
+    extern "C" {
+        fn sbss();
+        fn ebss();
     }
-    unsafe {
-        core::slice::from_raw_parts_mut(sbss as usize as *mut u8, ebss as usize - sbss as usize)
-            .fill(0);
+    unsafe {
+        core::slice::from_raw_parts_mut(sbss as usize as *mut u8, ebss as usize - sbss as usize)
+            .fill(0);
     }
 }
 
-#[no_mangle]
-/// the rust entry-point of os
-pub fn rust_main() -> ! {
-    clear_bss();
+#[no_mangle]
+/// the rust entry-point of os
+pub fn rust_main() -> ! {
+    clear_bss();
     println!("[kernel] Hello, world!");
-    mm::init();
-    mm::remap_test();
-    task::add_initproc();
+    mm::init();
+    mm::remap_test();
+    task::add_initproc();
     println!("after initproc!");
-    trap::init();
-    //trap::enable_interrupt();
-    trap::enable_timer_interrupt();
-    timer::set_next_trigger();
-    loader::list_apps();
-    task::run_tasks();
+    trap::init();
+    //trap::enable_interrupt();
+    trap::enable_timer_interrupt();
+    timer::set_next_trigger();
+    loader::list_apps();
+    task::run_tasks();
     panic!("Unreachable in rust_main!");
 }
-
    
-
    \ No newline at end of file + \ No newline at end of file diff --git a/ch5/src/os/mm/address.rs.html b/ch5/src/os/mm/address.rs.html index e2244fe5..8b6f42f5 100644 --- a/ch5/src/os/mm/address.rs.html +++ b/ch5/src/os/mm/address.rs.html @@ -1,552 +1,551 @@ -address.rs - source
    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
-198
-199
-200
-201
-202
-203
-204
-205
-206
-207
-208
-209
-210
-211
-212
-213
-214
-215
-216
-217
-218
-219
-220
-221
-222
-223
-224
-225
-226
-227
-228
-229
-230
-231
-232
-233
-234
-235
-236
-237
-238
-239
-240
-241
-242
-243
-244
-245
-246
-247
-248
-249
-250
-251
-252
-253
-254
-255
-256
-257
-258
-259
-260
-261
-262
-263
-264
-265
-266
-267
-268
-269
-270
-271
-272
-273
-274
-275
-
    //! Implementation of physical and virtual address and page number.
-use super::PageTableEntry;
-use crate::config::{PAGE_SIZE, PAGE_SIZE_BITS};
-use core::fmt::{self, Debug, Formatter};
-/// physical address
-const PA_WIDTH_SV39: usize = 56;
-const VA_WIDTH_SV39: usize = 39;
-const PPN_WIDTH_SV39: usize = PA_WIDTH_SV39 - PAGE_SIZE_BITS;
-const VPN_WIDTH_SV39: usize = VA_WIDTH_SV39 - PAGE_SIZE_BITS;
+address.rs - source
    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
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+219
+220
+221
+222
+223
+224
+225
+226
+227
+228
+229
+230
+231
+232
+233
+234
+235
+236
+237
+238
+239
+240
+241
+242
+243
+244
+245
+246
+247
+248
+249
+250
+251
+252
+253
+254
+255
+256
+257
+258
+259
+260
+261
+262
+263
+264
+265
+266
+267
+268
+269
+270
+271
+272
+273
+274
+275
+
    //! Implementation of physical and virtual address and page number.
+use super::PageTableEntry;
+use crate::config::{PAGE_SIZE, PAGE_SIZE_BITS};
+use core::fmt::{self, Debug, Formatter};
+/// physical address
+const PA_WIDTH_SV39: usize = 56;
+const VA_WIDTH_SV39: usize = 39;
+const PPN_WIDTH_SV39: usize = PA_WIDTH_SV39 - PAGE_SIZE_BITS;
+const VPN_WIDTH_SV39: usize = VA_WIDTH_SV39 - PAGE_SIZE_BITS;
 
-/// physical address
-#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
-pub struct PhysAddr(pub usize);
-/// virtual address
-#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
-pub struct VirtAddr(pub usize);
-/// physical page number
-#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
-pub struct PhysPageNum(pub usize);
-/// virtual page number
-#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
-pub struct VirtPageNum(pub usize);
+/// physical address
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
+pub struct PhysAddr(pub usize);
+/// virtual address
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
+pub struct VirtAddr(pub usize);
+/// physical page number
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
+pub struct PhysPageNum(pub usize);
+/// virtual page number
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
+pub struct VirtPageNum(pub usize);
 
-/// Debugging
+/// Debugging
 
-impl Debug for VirtAddr {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.write_fmt(format_args!("VA:{:#x}", self.0))
+impl Debug for VirtAddr {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.write_fmt(format_args!("VA:{:#x}", self.0))
     }
 }
-impl Debug for VirtPageNum {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.write_fmt(format_args!("VPN:{:#x}", self.0))
+impl Debug for VirtPageNum {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.write_fmt(format_args!("VPN:{:#x}", self.0))
     }
 }
-impl Debug for PhysAddr {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.write_fmt(format_args!("PA:{:#x}", self.0))
+impl Debug for PhysAddr {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.write_fmt(format_args!("PA:{:#x}", self.0))
     }
 }
-impl Debug for PhysPageNum {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.write_fmt(format_args!("PPN:{:#x}", self.0))
+impl Debug for PhysPageNum {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.write_fmt(format_args!("PPN:{:#x}", self.0))
     }
 }
 
-/// T: {PhysAddr, VirtAddr, PhysPageNum, VirtPageNum}
-/// T -> usize: T.0
-/// usize -> T: usize.into()
+/// T: {PhysAddr, VirtAddr, PhysPageNum, VirtPageNum}
+/// T -> usize: T.0
+/// usize -> T: usize.into()
 
-impl From<usize> for PhysAddr {
-    fn from(v: usize) -> Self {
-        Self(v & ((1 << PA_WIDTH_SV39) - 1))
+impl From<usize> for PhysAddr {
+    fn from(v: usize) -> Self {
+        Self(v & ((1 << PA_WIDTH_SV39) - 1))
     }
 }
-impl From<usize> for PhysPageNum {
-    fn from(v: usize) -> Self {
-        Self(v & ((1 << PPN_WIDTH_SV39) - 1))
+impl From<usize> for PhysPageNum {
+    fn from(v: usize) -> Self {
+        Self(v & ((1 << PPN_WIDTH_SV39) - 1))
     }
 }
-impl From<usize> for VirtAddr {
-    fn from(v: usize) -> Self {
-        Self(v & ((1 << VA_WIDTH_SV39) - 1))
+impl From<usize> for VirtAddr {
+    fn from(v: usize) -> Self {
+        Self(v & ((1 << VA_WIDTH_SV39) - 1))
     }
 }
-impl From<usize> for VirtPageNum {
-    fn from(v: usize) -> Self {
-        Self(v & ((1 << VPN_WIDTH_SV39) - 1))
+impl From<usize> for VirtPageNum {
+    fn from(v: usize) -> Self {
+        Self(v & ((1 << VPN_WIDTH_SV39) - 1))
     }
 }
-impl From<PhysAddr> for usize {
-    fn from(v: PhysAddr) -> Self {
-        v.0
+impl From<PhysAddr> for usize {
+    fn from(v: PhysAddr) -> Self {
+        v.0
+    }
+}
+impl From<PhysPageNum> for usize {
+    fn from(v: PhysPageNum) -> Self {
+        v.0
+    }
+}
+impl From<VirtAddr> for usize {
+    fn from(v: VirtAddr) -> Self {
+        if v.0 >= (1 << (VA_WIDTH_SV39 - 1)) {
+            v.0 | (!((1 << VA_WIDTH_SV39) - 1))
+        } else {
+            v.0
+        }
     }
 }
-impl From<PhysPageNum> for usize {
-    fn from(v: PhysPageNum) -> Self {
-        v.0
+impl From<VirtPageNum> for usize {
+    fn from(v: VirtPageNum) -> Self {
+        v.0
+    }
+}
+///
+impl VirtAddr {
+    ///`VirtAddr`->`VirtPageNum`
+    pub fn floor(&self) -> VirtPageNum {
+        VirtPageNum(self.0 / PAGE_SIZE)
+    }
+    ///`VirtAddr`->`VirtPageNum`
+    pub fn ceil(&self) -> VirtPageNum {
+        if self.0 == 0 {
+            VirtPageNum(0)
+        } else {
+            VirtPageNum((self.0 - 1 + PAGE_SIZE) / PAGE_SIZE)
+        }
+    }
+    ///Get page offset
+    pub fn page_offset(&self) -> usize {
+        self.0 & (PAGE_SIZE - 1)
+    }
+    ///Check page aligned
+    pub fn aligned(&self) -> bool {
+        self.page_offset() == 0
+    }
+}
+impl From<VirtAddr> for VirtPageNum {
+    fn from(v: VirtAddr) -> Self {
+        assert_eq!(v.page_offset(), 0);
+        v.floor()
     }
 }
-impl From<VirtAddr> for usize {
-    fn from(v: VirtAddr) -> Self {
-        if v.0 >= (1 << (VA_WIDTH_SV39 - 1)) {
-            v.0 | (!((1 << VA_WIDTH_SV39) - 1))
-        } else {
-            v.0
+impl From<VirtPageNum> for VirtAddr {
+    fn from(v: VirtPageNum) -> Self {
+        Self(v.0 << PAGE_SIZE_BITS)
+    }
+}
+impl PhysAddr {
+    ///`PhysAddr`->`PhysPageNum`
+    pub fn floor(&self) -> PhysPageNum {
+        PhysPageNum(self.0 / PAGE_SIZE)
+    }
+    ///`PhysAddr`->`PhysPageNum`
+    pub fn ceil(&self) -> PhysPageNum {
+        if self.0 == 0 {
+            PhysPageNum(0)
+        } else {
+            PhysPageNum((self.0 - 1 + PAGE_SIZE) / PAGE_SIZE)
+        }
+    }
+    ///Get page offset
+    pub fn page_offset(&self) -> usize {
+        self.0 & (PAGE_SIZE - 1)
+    }
+    ///Check page aligned
+    pub fn aligned(&self) -> bool {
+        self.page_offset() == 0
+    }
+}
+impl From<PhysAddr> for PhysPageNum {
+    fn from(v: PhysAddr) -> Self {
+        assert_eq!(v.page_offset(), 0);
+        v.floor()
+    }
+}
+impl From<PhysPageNum> for PhysAddr {
+    fn from(v: PhysPageNum) -> Self {
+        Self(v.0 << PAGE_SIZE_BITS)
+    }
+}
+
+impl VirtPageNum {
+    ///Return VPN 3 level index
+    pub fn indexes(&self) -> [usize; 3] {
+        let mut vpn = self.0;
+        let mut idx = [0usize; 3];
+        for i in (0..3).rev() {
+            idx[i] = vpn & 511;
+            vpn >>= 9;
+        }
+        idx
+    }
+}
+
+impl PhysAddr {
+    ///Get mutable reference to `PhysAddr` value
+    pub fn get_mut<T>(&self) -> &'static mut T {
+        unsafe { (self.0 as *mut T).as_mut().unwrap() }
+    }
+}
+impl PhysPageNum {
+    ///Get `PageTableEntry` on `PhysPageNum`
+    pub fn get_pte_array(&self) -> &'static mut [PageTableEntry] {
+        let pa: PhysAddr = (*self).into();
+        unsafe { core::slice::from_raw_parts_mut(pa.0 as *mut PageTableEntry, 512) }
+    }
+    ///
+    pub fn get_bytes_array(&self) -> &'static mut [u8] {
+        let pa: PhysAddr = (*self).into();
+        unsafe { core::slice::from_raw_parts_mut(pa.0 as *mut u8, 4096) }
+    }
+    ///
+    pub fn get_mut<T>(&self) -> &'static mut T {
+        let pa: PhysAddr = (*self).into();
+        pa.get_mut()
+    }
+}
+
+pub trait StepByOne {
+    fn step(&mut self);
+}
+impl StepByOne for VirtPageNum {
+    fn step(&mut self) {
+        self.0 += 1;
+    }
+}
+
+#[derive(Copy, Clone)]
+/// a simple range structure for type T
+pub struct SimpleRange<T>
+where
+    T: StepByOne + Copy + PartialEq + PartialOrd + Debug,
+{
+    l: T,
+    r: T,
+}
+impl<T> SimpleRange<T>
+where
+    T: StepByOne + Copy + PartialEq + PartialOrd + Debug,
+{
+    pub fn new(start: T, end: T) -> Self {
+        assert!(start <= end, "start {:?} > end {:?}!", start, end);
+        Self { l: start, r: end }
+    }
+    pub fn get_start(&self) -> T {
+        self.l
+    }
+    pub fn get_end(&self) -> T {
+        self.r
+    }
+}
+impl<T> IntoIterator for SimpleRange<T>
+where
+    T: StepByOne + Copy + PartialEq + PartialOrd + Debug,
+{
+    type Item = T;
+    type IntoIter = SimpleRangeIterator<T>;
+    fn into_iter(self) -> Self::IntoIter {
+        SimpleRangeIterator::new(self.l, self.r)
+    }
+}
+/// iterator for the simple range structure
+pub struct SimpleRangeIterator<T>
+where
+    T: StepByOne + Copy + PartialEq + PartialOrd + Debug,
+{
+    current: T,
+    end: T,
+}
+impl<T> SimpleRangeIterator<T>
+where
+    T: StepByOne + Copy + PartialEq + PartialOrd + Debug,
+{
+    pub fn new(l: T, r: T) -> Self {
+        Self { current: l, end: r }
+    }
+}
+impl<T> Iterator for SimpleRangeIterator<T>
+where
+    T: StepByOne + Copy + PartialEq + PartialOrd + Debug,
+{
+    type Item = T;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.current == self.end {
+            None
+        } else {
+            let t = self.current;
+            self.current.step();
+            Some(t)
         }
     }
 }
-impl From<VirtPageNum> for usize {
-    fn from(v: VirtPageNum) -> Self {
-        v.0
-    }
-}
-///
-impl VirtAddr {
-    ///`VirtAddr`->`VirtPageNum`
-    pub fn floor(&self) -> VirtPageNum {
-        VirtPageNum(self.0 / PAGE_SIZE)
-    }
-    ///`VirtAddr`->`VirtPageNum`
-    pub fn ceil(&self) -> VirtPageNum {
-        if self.0 == 0 {
-            VirtPageNum(0)
-        } else {
-            VirtPageNum((self.0 - 1 + PAGE_SIZE) / PAGE_SIZE)
-        }
-    }
-    ///Get page offset
-    pub fn page_offset(&self) -> usize {
-        self.0 & (PAGE_SIZE - 1)
-    }
-    ///Check page aligned
-    pub fn aligned(&self) -> bool {
-        self.page_offset() == 0
-    }
-}
-impl From<VirtAddr> for VirtPageNum {
-    fn from(v: VirtAddr) -> Self {
-        assert_eq!(v.page_offset(), 0);
-        v.floor()
-    }
-}
-impl From<VirtPageNum> for VirtAddr {
-    fn from(v: VirtPageNum) -> Self {
-        Self(v.0 << PAGE_SIZE_BITS)
-    }
-}
-impl PhysAddr {
-    ///`PhysAddr`->`PhysPageNum`
-    pub fn floor(&self) -> PhysPageNum {
-        PhysPageNum(self.0 / PAGE_SIZE)
-    }
-    ///`PhysAddr`->`PhysPageNum`
-    pub fn ceil(&self) -> PhysPageNum {
-        if self.0 == 0 {
-            PhysPageNum(0)
-        } else {
-            PhysPageNum((self.0 - 1 + PAGE_SIZE) / PAGE_SIZE)
-        }
-    }
-    ///Get page offset
-    pub fn page_offset(&self) -> usize {
-        self.0 & (PAGE_SIZE - 1)
-    }
-    ///Check page aligned
-    pub fn aligned(&self) -> bool {
-        self.page_offset() == 0
-    }
-}
-impl From<PhysAddr> for PhysPageNum {
-    fn from(v: PhysAddr) -> Self {
-        assert_eq!(v.page_offset(), 0);
-        v.floor()
-    }
-}
-impl From<PhysPageNum> for PhysAddr {
-    fn from(v: PhysPageNum) -> Self {
-        Self(v.0 << PAGE_SIZE_BITS)
-    }
-}
-
-impl VirtPageNum {
-    ///Return VPN 3 level index
-    pub fn indexes(&self) -> [usize; 3] {
-        let mut vpn = self.0;
-        let mut idx = [0usize; 3];
-        for i in (0..3).rev() {
-            idx[i] = vpn & 511;
-            vpn >>= 9;
-        }
-        idx
-    }
-}
-
-impl PhysAddr {
-    ///Get mutable reference to `PhysAddr` value
-    pub fn get_mut<T>(&self) -> &'static mut T {
-        unsafe { (self.0 as *mut T).as_mut().unwrap() }
-    }
-}
-impl PhysPageNum {
-    ///Get `PageTableEntry` on `PhysPageNum`
-    pub fn get_pte_array(&self) -> &'static mut [PageTableEntry] {
-        let pa: PhysAddr = (*self).into();
-        unsafe { core::slice::from_raw_parts_mut(pa.0 as *mut PageTableEntry, 512) }
-    }
-    ///
-    pub fn get_bytes_array(&self) -> &'static mut [u8] {
-        let pa: PhysAddr = (*self).into();
-        unsafe { core::slice::from_raw_parts_mut(pa.0 as *mut u8, 4096) }
-    }
-    ///
-    pub fn get_mut<T>(&self) -> &'static mut T {
-        let pa: PhysAddr = (*self).into();
-        pa.get_mut()
-    }
-}
-
-pub trait StepByOne {
-    fn step(&mut self);
-}
-impl StepByOne for VirtPageNum {
-    fn step(&mut self) {
-        self.0 += 1;
-    }
-}
-
-#[derive(Copy, Clone)]
-/// a simple range structure for type T
-pub struct SimpleRange<T>
-where
-    T: StepByOne + Copy + PartialEq + PartialOrd + Debug,
-{
-    l: T,
-    r: T,
-}
-impl<T> SimpleRange<T>
-where
-    T: StepByOne + Copy + PartialEq + PartialOrd + Debug,
-{
-    pub fn new(start: T, end: T) -> Self {
-        assert!(start <= end, "start {:?} > end {:?}!", start, end);
-        Self { l: start, r: end }
-    }
-    pub fn get_start(&self) -> T {
-        self.l
-    }
-    pub fn get_end(&self) -> T {
-        self.r
-    }
-}
-impl<T> IntoIterator for SimpleRange<T>
-where
-    T: StepByOne + Copy + PartialEq + PartialOrd + Debug,
-{
-    type Item = T;
-    type IntoIter = SimpleRangeIterator<T>;
-    fn into_iter(self) -> Self::IntoIter {
-        SimpleRangeIterator::new(self.l, self.r)
-    }
-}
-/// iterator for the simple range structure
-pub struct SimpleRangeIterator<T>
-where
-    T: StepByOne + Copy + PartialEq + PartialOrd + Debug,
-{
-    current: T,
-    end: T,
-}
-impl<T> SimpleRangeIterator<T>
-where
-    T: StepByOne + Copy + PartialEq + PartialOrd + Debug,
-{
-    pub fn new(l: T, r: T) -> Self {
-        Self { current: l, end: r }
-    }
-}
-impl<T> Iterator for SimpleRangeIterator<T>
-where
-    T: StepByOne + Copy + PartialEq + PartialOrd + Debug,
-{
-    type Item = T;
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.current == self.end {
-            None
-        } else {
-            let t = self.current;
-            self.current.step();
-            Some(t)
-        }
-    }
-}
-/// a simple range structure for virtual page number
-pub type VPNRange = SimpleRange<VirtPageNum>;
-
    
-
    \ No newline at end of file +/// a simple range structure for virtual page number +pub type VPNRange = SimpleRange<VirtPageNum>; + \ No newline at end of file diff --git a/ch5/src/os/mm/frame_allocator.rs.html b/ch5/src/os/mm/frame_allocator.rs.html index aef8fb3d..98a2edb1 100644 --- a/ch5/src/os/mm/frame_allocator.rs.html +++ b/ch5/src/os/mm/frame_allocator.rs.html @@ -1,270 +1,269 @@ -frame_allocator.rs - source
    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
-
    //! Implementation of [`FrameAllocator`] which
-//! controls all the frames in the operating system.
-use super::{PhysAddr, PhysPageNum};
-use crate::config::MEMORY_END;
-use crate::sync::UPSafeCell;
-use alloc::vec::Vec;
-use core::fmt::{self, Debug, Formatter};
-use lazy_static::*;
+frame_allocator.rs - source
    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
+
    //! Implementation of [`FrameAllocator`] which
+//! controls all the frames in the operating system.
+use super::{PhysAddr, PhysPageNum};
+use crate::config::MEMORY_END;
+use crate::sync::UPSafeCell;
+use alloc::vec::Vec;
+use core::fmt::{self, Debug, Formatter};
+use lazy_static::*;
 
-/// manage a frame which has the same lifecycle as the tracker
-pub struct FrameTracker {
-    ///
-    pub ppn: PhysPageNum,
+/// manage a frame which has the same lifecycle as the tracker
+pub struct FrameTracker {
+    ///
+    pub ppn: PhysPageNum,
 }
 
-impl FrameTracker {
-    ///Create an empty `FrameTracker`
-    pub fn new(ppn: PhysPageNum) -> Self {
-        // page cleaning
-        let bytes_array = ppn.get_bytes_array();
-        for i in bytes_array {
-            *i = 0;
+impl FrameTracker {
+    ///Create an empty `FrameTracker`
+    pub fn new(ppn: PhysPageNum) -> Self {
+        // page cleaning
+        let bytes_array = ppn.get_bytes_array();
+        for i in bytes_array {
+            *i = 0;
         }
-        Self { ppn }
+        Self { ppn }
     }
 }
 
-impl Debug for FrameTracker {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.write_fmt(format_args!("FrameTracker:PPN={:#x}", self.ppn.0))
+impl Debug for FrameTracker {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.write_fmt(format_args!("FrameTracker:PPN={:#x}", self.ppn.0))
     }
 }
 
-impl Drop for FrameTracker {
-    fn drop(&mut self) {
-        frame_dealloc(self.ppn);
+impl Drop for FrameTracker {
+    fn drop(&mut self) {
+        frame_dealloc(self.ppn);
     }
 }
 
-trait FrameAllocator {
-    fn new() -> Self;
-    fn alloc(&mut self) -> Option<PhysPageNum>;
-    fn dealloc(&mut self, ppn: PhysPageNum);
+trait FrameAllocator {
+    fn new() -> Self;
+    fn alloc(&mut self) -> Option<PhysPageNum>;
+    fn dealloc(&mut self, ppn: PhysPageNum);
 }
-/// an implementation for frame allocator
-pub struct StackFrameAllocator {
-    current: usize,
-    end: usize,
-    recycled: Vec<usize>,
+/// an implementation for frame allocator
+pub struct StackFrameAllocator {
+    current: usize,
+    end: usize,
+    recycled: Vec<usize>,
 }
 
-impl StackFrameAllocator {
-    pub fn init(&mut self, l: PhysPageNum, r: PhysPageNum) {
-        self.current = l.0;
-        self.end = r.0;
-        println!("last {} Physical Frames.", self.end - self.current);
+impl StackFrameAllocator {
+    pub fn init(&mut self, l: PhysPageNum, r: PhysPageNum) {
+        self.current = l.0;
+        self.end = r.0;
+        println!("last {} Physical Frames.", self.end - self.current);
     }
 }
-impl FrameAllocator for StackFrameAllocator {
-    fn new() -> Self {
-        Self {
-            current: 0,
-            end: 0,
-            recycled: Vec::new(),
+impl FrameAllocator for StackFrameAllocator {
+    fn new() -> Self {
+        Self {
+            current: 0,
+            end: 0,
+            recycled: Vec::new(),
         }
     }
-    fn alloc(&mut self) -> Option<PhysPageNum> {
-        if let Some(ppn) = self.recycled.pop() {
-            Some(ppn.into())
-        } else if self.current == self.end {
-            None
-        } else {
-            self.current += 1;
-            Some((self.current - 1).into())
+    fn alloc(&mut self) -> Option<PhysPageNum> {
+        if let Some(ppn) = self.recycled.pop() {
+            Some(ppn.into())
+        } else if self.current == self.end {
+            None
+        } else {
+            self.current += 1;
+            Some((self.current - 1).into())
         }
     }
-    fn dealloc(&mut self, ppn: PhysPageNum) {
-        let ppn = ppn.0;
-        // validity check
-        if ppn >= self.current || self.recycled.iter().any(|&v| v == ppn) {
-            panic!("Frame ppn={:#x} has not been allocated!", ppn);
+    fn dealloc(&mut self, ppn: PhysPageNum) {
+        let ppn = ppn.0;
+        // validity check
+        if ppn >= self.current || self.recycled.iter().any(|&v| v == ppn) {
+            panic!("Frame ppn={:#x} has not been allocated!", ppn);
         }
-        // recycle
-        self.recycled.push(ppn);
+        // recycle
+        self.recycled.push(ppn);
     }
 }
 
-type FrameAllocatorImpl = StackFrameAllocator;
+type FrameAllocatorImpl = StackFrameAllocator;
 
-lazy_static! {
-    /// frame allocator instance through lazy_static!
-    pub static ref FRAME_ALLOCATOR: UPSafeCell<FrameAllocatorImpl> =
-        unsafe { UPSafeCell::new(FrameAllocatorImpl::new()) };
+lazy_static! {
+    /// frame allocator instance through lazy_static!
+    pub static ref FRAME_ALLOCATOR: UPSafeCell<FrameAllocatorImpl> =
+        unsafe { UPSafeCell::new(FrameAllocatorImpl::new()) };
 }
-/// initiate the frame allocator using `ekernel` and `MEMORY_END`
-pub fn init_frame_allocator() {
-    extern "C" {
-        fn ekernel();
+/// initiate the frame allocator using `ekernel` and `MEMORY_END`
+pub fn init_frame_allocator() {
+    extern "C" {
+        fn ekernel();
     }
-    FRAME_ALLOCATOR.exclusive_access().init(
-        PhysAddr::from(ekernel as usize).ceil(),
-        PhysAddr::from(MEMORY_END).floor(),
+    FRAME_ALLOCATOR.exclusive_access().init(
+        PhysAddr::from(ekernel as usize).ceil(),
+        PhysAddr::from(MEMORY_END).floor(),
     );
 }
-/// allocate a frame
-pub fn frame_alloc() -> Option<FrameTracker> {
-    FRAME_ALLOCATOR
-        .exclusive_access()
-        .alloc()
-        .map(FrameTracker::new)
+/// allocate a frame
+pub fn frame_alloc() -> Option<FrameTracker> {
+    FRAME_ALLOCATOR
+        .exclusive_access()
+        .alloc()
+        .map(FrameTracker::new)
 }
-/// deallocate a frame
-fn frame_dealloc(ppn: PhysPageNum) {
-    FRAME_ALLOCATOR.exclusive_access().dealloc(ppn);
+/// deallocate a frame
+fn frame_dealloc(ppn: PhysPageNum) {
+    FRAME_ALLOCATOR.exclusive_access().dealloc(ppn);
 }
 
-#[allow(unused)]
-/// a simple test for frame allocator
-pub fn frame_allocator_test() {
-    let mut v: Vec<FrameTracker> = Vec::new();
-    for i in 0..5 {
-        let frame = frame_alloc().unwrap();
-        println!("{:?}", frame);
-        v.push(frame);
+#[allow(unused)]
+/// a simple test for frame allocator
+pub fn frame_allocator_test() {
+    let mut v: Vec<FrameTracker> = Vec::new();
+    for i in 0..5 {
+        let frame = frame_alloc().unwrap();
+        println!("{:?}", frame);
+        v.push(frame);
     }
-    v.clear();
-    for i in 0..5 {
-        let frame = frame_alloc().unwrap();
-        println!("{:?}", frame);
-        v.push(frame);
+    v.clear();
+    for i in 0..5 {
+        let frame = frame_alloc().unwrap();
+        println!("{:?}", frame);
+        v.push(frame);
     }
-    drop(v);
+    drop(v);
     println!("frame_allocator_test passed!");
 }
-
    
-
    \ No newline at end of file + \ No newline at end of file diff --git a/ch5/src/os/mm/heap_allocator.rs.html b/ch5/src/os/mm/heap_allocator.rs.html index 93168f2d..50696648 100644 --- a/ch5/src/os/mm/heap_allocator.rs.html +++ b/ch5/src/os/mm/heap_allocator.rs.html @@ -1,98 +1,97 @@ -heap_allocator.rs - source
    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
-
    //! The global allocator
-use crate::config::KERNEL_HEAP_SIZE;
-use buddy_system_allocator::LockedHeap;
+heap_allocator.rs - source
    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
+
    //! The global allocator
+use crate::config::KERNEL_HEAP_SIZE;
+use buddy_system_allocator::LockedHeap;
 
-#[global_allocator]
-/// heap allocator instance
-static HEAP_ALLOCATOR: LockedHeap = LockedHeap::empty();
+#[global_allocator]
+/// heap allocator instance
+static HEAP_ALLOCATOR: LockedHeap = LockedHeap::empty();
 
-#[alloc_error_handler]
-/// panic when heap allocation error occurs
-pub fn handle_alloc_error(layout: core::alloc::Layout) -> ! {
-    panic!("Heap allocation error, layout = {:?}", layout);
+#[alloc_error_handler]
+/// panic when heap allocation error occurs
+pub fn handle_alloc_error(layout: core::alloc::Layout) -> ! {
+    panic!("Heap allocation error, layout = {:?}", layout);
 }
-/// heap space ([u8; KERNEL_HEAP_SIZE])
-static mut HEAP_SPACE: [u8; KERNEL_HEAP_SIZE] = [0; KERNEL_HEAP_SIZE];
-/// initiate heap allocator
-pub fn init_heap() {
-    unsafe {
-        HEAP_ALLOCATOR
-            .lock()
-            .init(HEAP_SPACE.as_ptr() as usize, KERNEL_HEAP_SIZE);
+/// heap space ([u8; KERNEL_HEAP_SIZE])
+static mut HEAP_SPACE: [u8; KERNEL_HEAP_SIZE] = [0; KERNEL_HEAP_SIZE];
+/// initiate heap allocator
+pub fn init_heap() {
+    unsafe {
+        HEAP_ALLOCATOR
+            .lock()
+            .init(HEAP_SPACE.as_ptr() as usize, KERNEL_HEAP_SIZE);
     }
 }
 
-#[allow(unused)]
-pub fn heap_test() {
-    use alloc::boxed::Box;
-    use alloc::vec::Vec;
-    extern "C" {
-        fn sbss();
-        fn ebss();
+#[allow(unused)]
+pub fn heap_test() {
+    use alloc::boxed::Box;
+    use alloc::vec::Vec;
+    extern "C" {
+        fn sbss();
+        fn ebss();
     }
-    let bss_range = sbss as usize..ebss as usize;
-    let a = Box::new(5);
-    assert_eq!(*a, 5);
-    assert!(bss_range.contains(&(a.as_ref() as *const _ as usize)));
-    drop(a);
-    let mut v: Vec<usize> = Vec::new();
-    for i in 0..500 {
-        v.push(i);
+    let bss_range = sbss as usize..ebss as usize;
+    let a = Box::new(5);
+    assert_eq!(*a, 5);
+    assert!(bss_range.contains(&(a.as_ref() as *const _ as usize)));
+    drop(a);
+    let mut v: Vec<usize> = Vec::new();
+    for i in 0..500 {
+        v.push(i);
     }
-    for (i, val) in v.iter().take(500).enumerate() {
-        assert_eq!(*val, i);
+    for (i, val) in v.iter().take(500).enumerate() {
+        assert_eq!(*val, i);
     }
-    assert!(bss_range.contains(&(v.as_ptr() as usize)));
-    drop(v);
+    assert!(bss_range.contains(&(v.as_ptr() as usize)));
+    drop(v);
     println!("heap_test passed!");
 }
-
    
-
    \ No newline at end of file + \ No newline at end of file diff --git a/ch5/src/os/mm/memory_set.rs.html b/ch5/src/os/mm/memory_set.rs.html index d6361b90..d2da37fd 100644 --- a/ch5/src/os/mm/memory_set.rs.html +++ b/ch5/src/os/mm/memory_set.rs.html @@ -1,810 +1,809 @@ -memory_set.rs - source
    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
-198
-199
-200
-201
-202
-203
-204
-205
-206
-207
-208
-209
-210
-211
-212
-213
-214
-215
-216
-217
-218
-219
-220
-221
-222
-223
-224
-225
-226
-227
-228
-229
-230
-231
-232
-233
-234
-235
-236
-237
-238
-239
-240
-241
-242
-243
-244
-245
-246
-247
-248
-249
-250
-251
-252
-253
-254
-255
-256
-257
-258
-259
-260
-261
-262
-263
-264
-265
-266
-267
-268
-269
-270
-271
-272
-273
-274
-275
-276
-277
-278
-279
-280
-281
-282
-283
-284
-285
-286
-287
-288
-289
-290
-291
-292
-293
-294
-295
-296
-297
-298
-299
-300
-301
-302
-303
-304
-305
-306
-307
-308
-309
-310
-311
-312
-313
-314
-315
-316
-317
-318
-319
-320
-321
-322
-323
-324
-325
-326
-327
-328
-329
-330
-331
-332
-333
-334
-335
-336
-337
-338
-339
-340
-341
-342
-343
-344
-345
-346
-347
-348
-349
-350
-351
-352
-353
-354
-355
-356
-357
-358
-359
-360
-361
-362
-363
-364
-365
-366
-367
-368
-369
-370
-371
-372
-373
-374
-375
-376
-377
-378
-379
-380
-381
-382
-383
-384
-385
-386
-387
-388
-389
-390
-391
-392
-393
-394
-395
-396
-397
-398
-399
-400
-401
-402
-403
-404
-
    //! Implementation of [`MapArea`] and [`MemorySet`].
-use super::{frame_alloc, FrameTracker};
-use super::{PTEFlags, PageTable, PageTableEntry};
-use super::{PhysAddr, PhysPageNum, VirtAddr, VirtPageNum};
-use super::{StepByOne, VPNRange};
-use crate::config::{MEMORY_END, MMIO, PAGE_SIZE, TRAMPOLINE, TRAP_CONTEXT, USER_STACK_SIZE};
-use crate::sync::UPSafeCell;
-use alloc::collections::BTreeMap;
-use alloc::sync::Arc;
-use alloc::vec::Vec;
-use core::arch::asm;
-use lazy_static::*;
-use riscv::register::satp;
+memory_set.rs - source
    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
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+219
+220
+221
+222
+223
+224
+225
+226
+227
+228
+229
+230
+231
+232
+233
+234
+235
+236
+237
+238
+239
+240
+241
+242
+243
+244
+245
+246
+247
+248
+249
+250
+251
+252
+253
+254
+255
+256
+257
+258
+259
+260
+261
+262
+263
+264
+265
+266
+267
+268
+269
+270
+271
+272
+273
+274
+275
+276
+277
+278
+279
+280
+281
+282
+283
+284
+285
+286
+287
+288
+289
+290
+291
+292
+293
+294
+295
+296
+297
+298
+299
+300
+301
+302
+303
+304
+305
+306
+307
+308
+309
+310
+311
+312
+313
+314
+315
+316
+317
+318
+319
+320
+321
+322
+323
+324
+325
+326
+327
+328
+329
+330
+331
+332
+333
+334
+335
+336
+337
+338
+339
+340
+341
+342
+343
+344
+345
+346
+347
+348
+349
+350
+351
+352
+353
+354
+355
+356
+357
+358
+359
+360
+361
+362
+363
+364
+365
+366
+367
+368
+369
+370
+371
+372
+373
+374
+375
+376
+377
+378
+379
+380
+381
+382
+383
+384
+385
+386
+387
+388
+389
+390
+391
+392
+393
+394
+395
+396
+397
+398
+399
+400
+401
+402
+403
+404
+
    //! Implementation of [`MapArea`] and [`MemorySet`].
+use super::{frame_alloc, FrameTracker};
+use super::{PTEFlags, PageTable, PageTableEntry};
+use super::{PhysAddr, PhysPageNum, VirtAddr, VirtPageNum};
+use super::{StepByOne, VPNRange};
+use crate::config::{MEMORY_END, MMIO, PAGE_SIZE, TRAMPOLINE, TRAP_CONTEXT, USER_STACK_SIZE};
+use crate::sync::UPSafeCell;
+use alloc::collections::BTreeMap;
+use alloc::sync::Arc;
+use alloc::vec::Vec;
+use core::arch::asm;
+use lazy_static::*;
+use riscv::register::satp;
 
-extern "C" {
-    fn stext();
-    fn etext();
-    fn srodata();
-    fn erodata();
-    fn sdata();
-    fn edata();
-    fn sbss_with_stack();
-    fn ebss();
-    fn ekernel();
-    fn strampoline();
+extern "C" {
+    fn stext();
+    fn etext();
+    fn srodata();
+    fn erodata();
+    fn sdata();
+    fn edata();
+    fn sbss_with_stack();
+    fn ebss();
+    fn ekernel();
+    fn strampoline();
 }
 
-lazy_static! {
-    /// a memory set instance through lazy_static! managing kernel space
-    pub static ref KERNEL_SPACE: Arc<UPSafeCell<MemorySet>> =
-        Arc::new(unsafe { UPSafeCell::new(MemorySet::new_kernel()) });
+lazy_static! {
+    /// a memory set instance through lazy_static! managing kernel space
+    pub static ref KERNEL_SPACE: Arc<UPSafeCell<MemorySet>> =
+        Arc::new(unsafe { UPSafeCell::new(MemorySet::new_kernel()) });
 }
-/// memory set structure, controls virtual-memory space
-pub struct MemorySet {
-    page_table: PageTable,
-    areas: Vec<MapArea>,
+/// memory set structure, controls virtual-memory space
+pub struct MemorySet {
+    page_table: PageTable,
+    areas: Vec<MapArea>,
 }
 
-impl MemorySet {
-    ///Create an empty `MemorySet`
-    pub fn new_bare() -> Self {
-        Self {
-            page_table: PageTable::new(),
-            areas: Vec::new(),
+impl MemorySet {
+    ///Create an empty `MemorySet`
+    pub fn new_bare() -> Self {
+        Self {
+            page_table: PageTable::new(),
+            areas: Vec::new(),
         }
     }
-    ///Get pagetable `root_ppn`
-    pub fn token(&self) -> usize {
-        self.page_table.token()
+    ///Get pagetable `root_ppn`
+    pub fn token(&self) -> usize {
+        self.page_table.token()
     }
-    /// Assume that no conflicts.
-    pub fn insert_framed_area(
-        &mut self,
-        start_va: VirtAddr,
-        end_va: VirtAddr,
-        permission: MapPermission,
+    /// Assume that no conflicts.
+    pub fn insert_framed_area(
+        &mut self,
+        start_va: VirtAddr,
+        end_va: VirtAddr,
+        permission: MapPermission,
     ) {
-        self.push(
-            MapArea::new(start_va, end_va, MapType::Framed, permission),
+        self.push(
+            MapArea::new(start_va, end_va, MapType::Framed, permission),
             None,
         );
     }
-    ///Remove `MapArea` that starts with `start_vpn`
-    pub fn remove_area_with_start_vpn(&mut self, start_vpn: VirtPageNum) {
-        if let Some((idx, area)) = self
-            .areas
-            .iter_mut()
-            .enumerate()
-            .find(|(_, area)| area.vpn_range.get_start() == start_vpn)
+    ///Remove `MapArea` that starts with `start_vpn`
+    pub fn remove_area_with_start_vpn(&mut self, start_vpn: VirtPageNum) {
+        if let Some((idx, area)) = self
+            .areas
+            .iter_mut()
+            .enumerate()
+            .find(|(_, area)| area.vpn_range.get_start() == start_vpn)
         {
-            area.unmap(&mut self.page_table);
-            self.areas.remove(idx);
+            area.unmap(&mut self.page_table);
+            self.areas.remove(idx);
         }
     }
-    fn push(&mut self, mut map_area: MapArea, data: Option<&[u8]>) {
-        map_area.map(&mut self.page_table);
-        if let Some(data) = data {
-            map_area.copy_data(&mut self.page_table, data);
+    fn push(&mut self, mut map_area: MapArea, data: Option<&[u8]>) {
+        map_area.map(&mut self.page_table);
+        if let Some(data) = data {
+            map_area.copy_data(&mut self.page_table, data);
         }
-        self.areas.push(map_area);
+        self.areas.push(map_area);
     }
-    /// Mention that trampoline is not collected by areas.
-    fn map_trampoline(&mut self) {
-        self.page_table.map(
-            VirtAddr::from(TRAMPOLINE).into(),
-            PhysAddr::from(strampoline as usize).into(),
-            PTEFlags::R | PTEFlags::X,
+    /// Mention that trampoline is not collected by areas.
+    fn map_trampoline(&mut self) {
+        self.page_table.map(
+            VirtAddr::from(TRAMPOLINE).into(),
+            PhysAddr::from(strampoline as usize).into(),
+            PTEFlags::R | PTEFlags::X,
         );
     }
-    /// Without kernel stacks.
-    pub fn new_kernel() -> Self {
-        let mut memory_set = Self::new_bare();
-        // map trampoline
-        memory_set.map_trampoline();
-        // map kernel sections
-        println!(".text [{:#x}, {:#x})", stext as usize, etext as usize);
-        println!(".rodata [{:#x}, {:#x})", srodata as usize, erodata as usize);
-        println!(".data [{:#x}, {:#x})", sdata as usize, edata as usize);
+    /// Without kernel stacks.
+    pub fn new_kernel() -> Self {
+        let mut memory_set = Self::new_bare();
+        // map trampoline
+        memory_set.map_trampoline();
+        // map kernel sections
+        println!(".text [{:#x}, {:#x})", stext as usize, etext as usize);
+        println!(".rodata [{:#x}, {:#x})", srodata as usize, erodata as usize);
+        println!(".data [{:#x}, {:#x})", sdata as usize, edata as usize);
         println!(
             ".bss [{:#x}, {:#x})",
-            sbss_with_stack as usize, ebss as usize
+            sbss_with_stack as usize, ebss as usize
         );
         println!("mapping .text section");
-        memory_set.push(
-            MapArea::new(
-                (stext as usize).into(),
-                (etext as usize).into(),
-                MapType::Identical,
-                MapPermission::R | MapPermission::X,
+        memory_set.push(
+            MapArea::new(
+                (stext as usize).into(),
+                (etext as usize).into(),
+                MapType::Identical,
+                MapPermission::R | MapPermission::X,
             ),
             None,
         );
         println!("mapping .rodata section");
-        memory_set.push(
-            MapArea::new(
-                (srodata as usize).into(),
-                (erodata as usize).into(),
-                MapType::Identical,
-                MapPermission::R,
+        memory_set.push(
+            MapArea::new(
+                (srodata as usize).into(),
+                (erodata as usize).into(),
+                MapType::Identical,
+                MapPermission::R,
             ),
             None,
         );
         println!("mapping .data section");
-        memory_set.push(
-            MapArea::new(
-                (sdata as usize).into(),
-                (edata as usize).into(),
-                MapType::Identical,
-                MapPermission::R | MapPermission::W,
+        memory_set.push(
+            MapArea::new(
+                (sdata as usize).into(),
+                (edata as usize).into(),
+                MapType::Identical,
+                MapPermission::R | MapPermission::W,
             ),
             None,
         );
         println!("mapping .bss section");
-        memory_set.push(
-            MapArea::new(
-                (sbss_with_stack as usize).into(),
-                (ebss as usize).into(),
-                MapType::Identical,
-                MapPermission::R | MapPermission::W,
+        memory_set.push(
+            MapArea::new(
+                (sbss_with_stack as usize).into(),
+                (ebss as usize).into(),
+                MapType::Identical,
+                MapPermission::R | MapPermission::W,
             ),
             None,
         );
         println!("mapping physical memory");
-        memory_set.push(
-            MapArea::new(
-                (ekernel as usize).into(),
-                MEMORY_END.into(),
-                MapType::Identical,
-                MapPermission::R | MapPermission::W,
+        memory_set.push(
+            MapArea::new(
+                (ekernel as usize).into(),
+                MEMORY_END.into(),
+                MapType::Identical,
+                MapPermission::R | MapPermission::W,
             ),
             None,
         );
         println!("mapping memory-mapped registers");
-        for pair in MMIO {
-            memory_set.push(
-                MapArea::new(
-                    (*pair).0.into(),
-                    ((*pair).0 + (*pair).1).into(),
-                    MapType::Identical,
-                    MapPermission::R | MapPermission::W,
+        for pair in MMIO {
+            memory_set.push(
+                MapArea::new(
+                    (*pair).0.into(),
+                    ((*pair).0 + (*pair).1).into(),
+                    MapType::Identical,
+                    MapPermission::R | MapPermission::W,
                 ),
                 None,
             );
         }
-        memory_set
+        memory_set
     }
-    /// Include sections in elf and trampoline and TrapContext and user stack,
-    /// also returns user_sp and entry point.
-    pub fn from_elf(elf_data: &[u8]) -> (Self, usize, usize) {
-        let mut memory_set = Self::new_bare();
-        // map trampoline
-        memory_set.map_trampoline();
-        // map program headers of elf, with U flag
-        let elf = xmas_elf::ElfFile::new(elf_data).unwrap();
-        let elf_header = elf.header;
-        let magic = elf_header.pt1.magic;
-        assert_eq!(magic, [0x7f, 0x45, 0x4c, 0x46], "invalid elf!");
-        let ph_count = elf_header.pt2.ph_count();
-        let mut max_end_vpn = VirtPageNum(0);
-        for i in 0..ph_count {
-            let ph = elf.program_header(i).unwrap();
-            if ph.get_type().unwrap() == xmas_elf::program::Type::Load {
-                let start_va: VirtAddr = (ph.virtual_addr() as usize).into();
-                let end_va: VirtAddr = ((ph.virtual_addr() + ph.mem_size()) as usize).into();
-                let mut map_perm = MapPermission::U;
-                let ph_flags = ph.flags();
-                if ph_flags.is_read() {
-                    map_perm |= MapPermission::R;
+    /// Include sections in elf and trampoline and TrapContext and user stack,
+    /// also returns user_sp and entry point.
+    pub fn from_elf(elf_data: &[u8]) -> (Self, usize, usize) {
+        let mut memory_set = Self::new_bare();
+        // map trampoline
+        memory_set.map_trampoline();
+        // map program headers of elf, with U flag
+        let elf = xmas_elf::ElfFile::new(elf_data).unwrap();
+        let elf_header = elf.header;
+        let magic = elf_header.pt1.magic;
+        assert_eq!(magic, [0x7f, 0x45, 0x4c, 0x46], "invalid elf!");
+        let ph_count = elf_header.pt2.ph_count();
+        let mut max_end_vpn = VirtPageNum(0);
+        for i in 0..ph_count {
+            let ph = elf.program_header(i).unwrap();
+            if ph.get_type().unwrap() == xmas_elf::program::Type::Load {
+                let start_va: VirtAddr = (ph.virtual_addr() as usize).into();
+                let end_va: VirtAddr = ((ph.virtual_addr() + ph.mem_size()) as usize).into();
+                let mut map_perm = MapPermission::U;
+                let ph_flags = ph.flags();
+                if ph_flags.is_read() {
+                    map_perm |= MapPermission::R;
                 }
-                if ph_flags.is_write() {
-                    map_perm |= MapPermission::W;
+                if ph_flags.is_write() {
+                    map_perm |= MapPermission::W;
                 }
-                if ph_flags.is_execute() {
-                    map_perm |= MapPermission::X;
+                if ph_flags.is_execute() {
+                    map_perm |= MapPermission::X;
                 }
-                let map_area = MapArea::new(start_va, end_va, MapType::Framed, map_perm);
-                max_end_vpn = map_area.vpn_range.get_end();
-                memory_set.push(
-                    map_area,
-                    Some(&elf.input[ph.offset() as usize..(ph.offset() + ph.file_size()) as usize]),
+                let map_area = MapArea::new(start_va, end_va, MapType::Framed, map_perm);
+                max_end_vpn = map_area.vpn_range.get_end();
+                memory_set.push(
+                    map_area,
+                    Some(&elf.input[ph.offset() as usize..(ph.offset() + ph.file_size()) as usize]),
                 );
             }
         }
-        // map user stack with U flags
-        let max_end_va: VirtAddr = max_end_vpn.into();
-        let mut user_stack_bottom: usize = max_end_va.into();
-        // guard page
-        user_stack_bottom += PAGE_SIZE;
-        let user_stack_top = user_stack_bottom + USER_STACK_SIZE;
-        memory_set.push(
-            MapArea::new(
-                user_stack_bottom.into(),
-                user_stack_top.into(),
-                MapType::Framed,
-                MapPermission::R | MapPermission::W | MapPermission::U,
+        // map user stack with U flags
+        let max_end_va: VirtAddr = max_end_vpn.into();
+        let mut user_stack_bottom: usize = max_end_va.into();
+        // guard page
+        user_stack_bottom += PAGE_SIZE;
+        let user_stack_top = user_stack_bottom + USER_STACK_SIZE;
+        memory_set.push(
+            MapArea::new(
+                user_stack_bottom.into(),
+                user_stack_top.into(),
+                MapType::Framed,
+                MapPermission::R | MapPermission::W | MapPermission::U,
             ),
             None,
         );
-        // map TrapContext
-        memory_set.push(
-            MapArea::new(
-                TRAP_CONTEXT.into(),
-                TRAMPOLINE.into(),
-                MapType::Framed,
-                MapPermission::R | MapPermission::W,
+        // map TrapContext
+        memory_set.push(
+            MapArea::new(
+                TRAP_CONTEXT.into(),
+                TRAMPOLINE.into(),
+                MapType::Framed,
+                MapPermission::R | MapPermission::W,
             ),
             None,
         );
         (
-            memory_set,
-            user_stack_top,
-            elf.header.pt2.entry_point() as usize,
+            memory_set,
+            user_stack_top,
+            elf.header.pt2.entry_point() as usize,
         )
     }
-    ///Clone a same `MemorySet`
-    pub fn from_existed_user(user_space: &Self) -> Self {
-        let mut memory_set = Self::new_bare();
-        // map trampoline
-        memory_set.map_trampoline();
-        // copy data sections/trap_context/user_stack
-        for area in user_space.areas.iter() {
-            let new_area = MapArea::from_another(area);
-            memory_set.push(new_area, None);
-            // copy data from another space
-            for vpn in area.vpn_range {
-                let src_ppn = user_space.translate(vpn).unwrap().ppn();
-                let dst_ppn = memory_set.translate(vpn).unwrap().ppn();
-                dst_ppn
-                    .get_bytes_array()
-                    .copy_from_slice(src_ppn.get_bytes_array());
+    ///Clone a same `MemorySet`
+    pub fn from_existed_user(user_space: &Self) -> Self {
+        let mut memory_set = Self::new_bare();
+        // map trampoline
+        memory_set.map_trampoline();
+        // copy data sections/trap_context/user_stack
+        for area in user_space.areas.iter() {
+            let new_area = MapArea::from_another(area);
+            memory_set.push(new_area, None);
+            // copy data from another space
+            for vpn in area.vpn_range {
+                let src_ppn = user_space.translate(vpn).unwrap().ppn();
+                let dst_ppn = memory_set.translate(vpn).unwrap().ppn();
+                dst_ppn
+                    .get_bytes_array()
+                    .copy_from_slice(src_ppn.get_bytes_array());
             }
         }
-        memory_set
+        memory_set
     }
-    ///Refresh TLB with `sfence.vma`
-    pub fn activate(&self) {
-        let satp = self.page_table.token();
-        unsafe {
-            satp::write(satp);
+    ///Refresh TLB with `sfence.vma`
+    pub fn activate(&self) {
+        let satp = self.page_table.token();
+        unsafe {
+            satp::write(satp);
             asm!("sfence.vma");
         }
     }
-    ///Translate throuth pagetable
-    pub fn translate(&self, vpn: VirtPageNum) -> Option<PageTableEntry> {
-        self.page_table.translate(vpn)
+    ///Translate throuth pagetable
+    pub fn translate(&self, vpn: VirtPageNum) -> Option<PageTableEntry> {
+        self.page_table.translate(vpn)
     }
-    ///Remove all `MapArea`
-    pub fn recycle_data_pages(&mut self) {
-        //*self = Self::new_bare();
-        self.areas.clear();
+    ///Remove all `MapArea`
+    pub fn recycle_data_pages(&mut self) {
+        //*self = Self::new_bare();
+        self.areas.clear();
     }
 }
-/// map area structure, controls a contiguous piece of virtual memory
-pub struct MapArea {
-    vpn_range: VPNRange,
-    data_frames: BTreeMap<VirtPageNum, FrameTracker>,
-    map_type: MapType,
-    map_perm: MapPermission,
+/// map area structure, controls a contiguous piece of virtual memory
+pub struct MapArea {
+    vpn_range: VPNRange,
+    data_frames: BTreeMap<VirtPageNum, FrameTracker>,
+    map_type: MapType,
+    map_perm: MapPermission,
 }
 
-impl MapArea {
-    pub fn new(
-        start_va: VirtAddr,
-        end_va: VirtAddr,
-        map_type: MapType,
-        map_perm: MapPermission,
-    ) -> Self {
-        let start_vpn: VirtPageNum = start_va.floor();
-        let end_vpn: VirtPageNum = end_va.ceil();
-        Self {
-            vpn_range: VPNRange::new(start_vpn, end_vpn),
-            data_frames: BTreeMap::new(),
-            map_type,
-            map_perm,
+impl MapArea {
+    pub fn new(
+        start_va: VirtAddr,
+        end_va: VirtAddr,
+        map_type: MapType,
+        map_perm: MapPermission,
+    ) -> Self {
+        let start_vpn: VirtPageNum = start_va.floor();
+        let end_vpn: VirtPageNum = end_va.ceil();
+        Self {
+            vpn_range: VPNRange::new(start_vpn, end_vpn),
+            data_frames: BTreeMap::new(),
+            map_type,
+            map_perm,
         }
     }
-    pub fn from_another(another: &Self) -> Self {
-        Self {
-            vpn_range: VPNRange::new(another.vpn_range.get_start(), another.vpn_range.get_end()),
-            data_frames: BTreeMap::new(),
-            map_type: another.map_type,
-            map_perm: another.map_perm,
+    pub fn from_another(another: &Self) -> Self {
+        Self {
+            vpn_range: VPNRange::new(another.vpn_range.get_start(), another.vpn_range.get_end()),
+            data_frames: BTreeMap::new(),
+            map_type: another.map_type,
+            map_perm: another.map_perm,
         }
     }
-    pub fn map_one(&mut self, page_table: &mut PageTable, vpn: VirtPageNum) {
-        let ppn: PhysPageNum;
-        match self.map_type {
-            MapType::Identical => {
-                ppn = PhysPageNum(vpn.0);
+    pub fn map_one(&mut self, page_table: &mut PageTable, vpn: VirtPageNum) {
+        let ppn: PhysPageNum;
+        match self.map_type {
+            MapType::Identical => {
+                ppn = PhysPageNum(vpn.0);
             }
-            MapType::Framed => {
-                let frame = frame_alloc().unwrap();
-                ppn = frame.ppn;
-                self.data_frames.insert(vpn, frame);
+            MapType::Framed => {
+                let frame = frame_alloc().unwrap();
+                ppn = frame.ppn;
+                self.data_frames.insert(vpn, frame);
             }
         }
-        let pte_flags = PTEFlags::from_bits(self.map_perm.bits).unwrap();
-        page_table.map(vpn, ppn, pte_flags);
+        let pte_flags = PTEFlags::from_bits(self.map_perm.bits).unwrap();
+        page_table.map(vpn, ppn, pte_flags);
     }
-    pub fn unmap_one(&mut self, page_table: &mut PageTable, vpn: VirtPageNum) {
-        if self.map_type == MapType::Framed {
-            self.data_frames.remove(&vpn);
+    pub fn unmap_one(&mut self, page_table: &mut PageTable, vpn: VirtPageNum) {
+        if self.map_type == MapType::Framed {
+            self.data_frames.remove(&vpn);
         }
-        page_table.unmap(vpn);
+        page_table.unmap(vpn);
     }
-    pub fn map(&mut self, page_table: &mut PageTable) {
-        for vpn in self.vpn_range {
-            self.map_one(page_table, vpn);
+    pub fn map(&mut self, page_table: &mut PageTable) {
+        for vpn in self.vpn_range {
+            self.map_one(page_table, vpn);
         }
     }
-    pub fn unmap(&mut self, page_table: &mut PageTable) {
-        for vpn in self.vpn_range {
-            self.unmap_one(page_table, vpn);
+    pub fn unmap(&mut self, page_table: &mut PageTable) {
+        for vpn in self.vpn_range {
+            self.unmap_one(page_table, vpn);
         }
     }
-    /// data: start-aligned but maybe with shorter length
-    /// assume that all frames were cleared before
-    pub fn copy_data(&mut self, page_table: &mut PageTable, data: &[u8]) {
-        assert_eq!(self.map_type, MapType::Framed);
-        let mut start: usize = 0;
-        let mut current_vpn = self.vpn_range.get_start();
-        let len = data.len();
-        loop {
-            let src = &data[start..len.min(start + PAGE_SIZE)];
-            let dst = &mut page_table
-                .translate(current_vpn)
-                .unwrap()
-                .ppn()
-                .get_bytes_array()[..src.len()];
-            dst.copy_from_slice(src);
-            start += PAGE_SIZE;
-            if start >= len {
+    /// data: start-aligned but maybe with shorter length
+    /// assume that all frames were cleared before
+    pub fn copy_data(&mut self, page_table: &mut PageTable, data: &[u8]) {
+        assert_eq!(self.map_type, MapType::Framed);
+        let mut start: usize = 0;
+        let mut current_vpn = self.vpn_range.get_start();
+        let len = data.len();
+        loop {
+            let src = &data[start..len.min(start + PAGE_SIZE)];
+            let dst = &mut page_table
+                .translate(current_vpn)
+                .unwrap()
+                .ppn()
+                .get_bytes_array()[..src.len()];
+            dst.copy_from_slice(src);
+            start += PAGE_SIZE;
+            if start >= len {
                 break;
             }
-            current_vpn.step();
+            current_vpn.step();
         }
     }
 }
 
-#[derive(Copy, Clone, PartialEq, Debug)]
-/// map type for memory set: identical or framed
-pub enum MapType {
-    Identical,
-    Framed,
+#[derive(Copy, Clone, PartialEq, Debug)]
+/// map type for memory set: identical or framed
+pub enum MapType {
+    Identical,
+    Framed,
 }
 
-bitflags! {
-    /// map permission corresponding to that in pte: `R W X U`
-    pub struct MapPermission: u8 {
-        ///Readable
-        const R = 1 << 1;
-        ///Writable
-        const W = 1 << 2;
-        ///Excutable
-        const X = 1 << 3;
-        ///Accessible in U mode
-        const U = 1 << 4;
+bitflags! {
+    /// map permission corresponding to that in pte: `R W X U`
+    pub struct MapPermission: u8 {
+        ///Readable
+        const R = 1 << 1;
+        ///Writable
+        const W = 1 << 2;
+        ///Excutable
+        const X = 1 << 3;
+        ///Accessible in U mode
+        const U = 1 << 4;
     }
 }
 
-#[allow(unused)]
-///Check PageTable running correctly
-pub fn remap_test() {
-    let mut kernel_space = KERNEL_SPACE.exclusive_access();
-    let mid_text: VirtAddr = ((stext as usize + etext as usize) / 2).into();
-    let mid_rodata: VirtAddr = ((srodata as usize + erodata as usize) / 2).into();
-    let mid_data: VirtAddr = ((sdata as usize + edata as usize) / 2).into();
-    assert!(!kernel_space
-        .page_table
-        .translate(mid_text.floor())
-        .unwrap()
-        .writable(),);
-    assert!(!kernel_space
-        .page_table
-        .translate(mid_rodata.floor())
-        .unwrap()
-        .writable(),);
-    assert!(!kernel_space
-        .page_table
-        .translate(mid_data.floor())
-        .unwrap()
-        .executable(),);
+#[allow(unused)]
+///Check PageTable running correctly
+pub fn remap_test() {
+    let mut kernel_space = KERNEL_SPACE.exclusive_access();
+    let mid_text: VirtAddr = ((stext as usize + etext as usize) / 2).into();
+    let mid_rodata: VirtAddr = ((srodata as usize + erodata as usize) / 2).into();
+    let mid_data: VirtAddr = ((sdata as usize + edata as usize) / 2).into();
+    assert!(!kernel_space
+        .page_table
+        .translate(mid_text.floor())
+        .unwrap()
+        .writable(),);
+    assert!(!kernel_space
+        .page_table
+        .translate(mid_rodata.floor())
+        .unwrap()
+        .writable(),);
+    assert!(!kernel_space
+        .page_table
+        .translate(mid_data.floor())
+        .unwrap()
+        .executable(),);
     println!("remap_test passed!");
 }
-
    
-
    \ No newline at end of file + \ No newline at end of file diff --git a/ch5/src/os/mm/mod.rs.html b/ch5/src/os/mm/mod.rs.html index 6aac7a37..952076a9 100644 --- a/ch5/src/os/mm/mod.rs.html +++ b/ch5/src/os/mm/mod.rs.html @@ -1,54 +1,53 @@ -mod.rs - source
    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
-
    //! Memory management implementation
-//!
-//! SV39 page-based virtual-memory architecture for RV64 systems, and
-//! everything about memory management, like frame allocator, page table,
-//! map area and memory set, is implemented here.
-//!
-//! Every task or process has a memory_set to control its virtual memory.
-mod address;
-mod frame_allocator;
-mod heap_allocator;
-mod memory_set;
-mod page_table;
+mod.rs - source
    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
+
    //! Memory management implementation
+//!
+//! SV39 page-based virtual-memory architecture for RV64 systems, and
+//! everything about memory management, like frame allocator, page table,
+//! map area and memory set, is implemented here.
+//!
+//! Every task or process has a memory_set to control its virtual memory.
+mod address;
+mod frame_allocator;
+mod heap_allocator;
+mod memory_set;
+mod page_table;
 
-pub use address::{PhysAddr, PhysPageNum, VirtAddr, VirtPageNum};
-use address::{StepByOne, VPNRange};
-pub use frame_allocator::{frame_alloc, FrameTracker};
-pub use memory_set::remap_test;
-pub use memory_set::{MapPermission, MemorySet, KERNEL_SPACE};
-pub use page_table::{translated_byte_buffer, translated_refmut, translated_str, PageTableEntry};
-use page_table::{PTEFlags, PageTable};
-/// initiate heap allocator, frame allocator and kernel space
-pub fn init() {
-    heap_allocator::init_heap();
-    frame_allocator::init_frame_allocator();
-    KERNEL_SPACE.exclusive_access().activate();
+pub use address::{PhysAddr, PhysPageNum, VirtAddr, VirtPageNum};
+use address::{StepByOne, VPNRange};
+pub use frame_allocator::{frame_alloc, FrameTracker};
+pub use memory_set::remap_test;
+pub use memory_set::{MapPermission, MemorySet, KERNEL_SPACE};
+pub use page_table::{translated_byte_buffer, translated_refmut, translated_str, PageTableEntry};
+use page_table::{PTEFlags, PageTable};
+/// initiate heap allocator, frame allocator and kernel space
+pub fn init() {
+    heap_allocator::init_heap();
+    frame_allocator::init_frame_allocator();
+    KERNEL_SPACE.exclusive_access().activate();
 }
-
    
-
    \ No newline at end of file + \ No newline at end of file diff --git a/ch5/src/os/mm/page_table.rs.html b/ch5/src/os/mm/page_table.rs.html index a4a3a08f..11973522 100644 --- a/ch5/src/os/mm/page_table.rs.html +++ b/ch5/src/os/mm/page_table.rs.html @@ -1,408 +1,407 @@ -page_table.rs - source
    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
-198
-199
-200
-201
-202
-203
-
    //! Implementation of [`PageTableEntry`] and [`PageTable`].
-use super::{frame_alloc, FrameTracker, PhysAddr, PhysPageNum, StepByOne, VirtAddr, VirtPageNum};
-use alloc::string::String;
-use alloc::vec;
-use alloc::vec::Vec;
-use bitflags::*;
+page_table.rs - source
    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
+198
+199
+200
+201
+202
+203
+
    //! Implementation of [`PageTableEntry`] and [`PageTable`].
+use super::{frame_alloc, FrameTracker, PhysAddr, PhysPageNum, StepByOne, VirtAddr, VirtPageNum};
+use alloc::string::String;
+use alloc::vec;
+use alloc::vec::Vec;
+use bitflags::*;
 
-bitflags! {
-    pub struct PTEFlags: u8 {
-        const V = 1 << 0;
-        const R = 1 << 1;
-        const W = 1 << 2;
-        const X = 1 << 3;
-        const U = 1 << 4;
-        const G = 1 << 5;
-        const A = 1 << 6;
-        const D = 1 << 7;
+bitflags! {
+    pub struct PTEFlags: u8 {
+        const V = 1 << 0;
+        const R = 1 << 1;
+        const W = 1 << 2;
+        const X = 1 << 3;
+        const U = 1 << 4;
+        const G = 1 << 5;
+        const A = 1 << 6;
+        const D = 1 << 7;
     }
 }
 
-#[derive(Copy, Clone)]
-#[repr(C)]
-/// page table entry structure
-pub struct PageTableEntry {
-    ///PTE
-    pub bits: usize,
+#[derive(Copy, Clone)]
+#[repr(C)]
+/// page table entry structure
+pub struct PageTableEntry {
+    ///PTE
+    pub bits: usize,
 }
 
-impl PageTableEntry {
-    ///Create a PTE from ppn
-    pub fn new(ppn: PhysPageNum, flags: PTEFlags) -> Self {
-        PageTableEntry {
-            bits: ppn.0 << 10 | flags.bits as usize,
+impl PageTableEntry {
+    ///Create a PTE from ppn
+    pub fn new(ppn: PhysPageNum, flags: PTEFlags) -> Self {
+        PageTableEntry {
+            bits: ppn.0 << 10 | flags.bits as usize,
         }
     }
-    ///Return an empty PTE
-    pub fn empty() -> Self {
-        PageTableEntry { bits: 0 }
+    ///Return an empty PTE
+    pub fn empty() -> Self {
+        PageTableEntry { bits: 0 }
     }
-    ///Return 44bit ppn
-    pub fn ppn(&self) -> PhysPageNum {
-        (self.bits >> 10 & ((1usize << 44) - 1)).into()
+    ///Return 44bit ppn
+    pub fn ppn(&self) -> PhysPageNum {
+        (self.bits >> 10 & ((1usize << 44) - 1)).into()
     }
-    ///Return 10bit flag
-    pub fn flags(&self) -> PTEFlags {
-        PTEFlags::from_bits(self.bits as u8).unwrap()
+    ///Return 10bit flag
+    pub fn flags(&self) -> PTEFlags {
+        PTEFlags::from_bits(self.bits as u8).unwrap()
     }
-    ///Check PTE valid
-    pub fn is_valid(&self) -> bool {
-        (self.flags() & PTEFlags::V) != PTEFlags::empty()
+    ///Check PTE valid
+    pub fn is_valid(&self) -> bool {
+        (self.flags() & PTEFlags::V) != PTEFlags::empty()
     }
-    ///Check PTE readable
-    pub fn readable(&self) -> bool {
-        (self.flags() & PTEFlags::R) != PTEFlags::empty()
+    ///Check PTE readable
+    pub fn readable(&self) -> bool {
+        (self.flags() & PTEFlags::R) != PTEFlags::empty()
     }
-    ///Check PTE writable
-    pub fn writable(&self) -> bool {
-        (self.flags() & PTEFlags::W) != PTEFlags::empty()
+    ///Check PTE writable
+    pub fn writable(&self) -> bool {
+        (self.flags() & PTEFlags::W) != PTEFlags::empty()
     }
-    ///Check PTE executable
-    pub fn executable(&self) -> bool {
-        (self.flags() & PTEFlags::X) != PTEFlags::empty()
+    ///Check PTE executable
+    pub fn executable(&self) -> bool {
+        (self.flags() & PTEFlags::X) != PTEFlags::empty()
     }
 }
 
-pub struct PageTable {
-    root_ppn: PhysPageNum,
-    frames: Vec<FrameTracker>,
+pub struct PageTable {
+    root_ppn: PhysPageNum,
+    frames: Vec<FrameTracker>,
 }
 
-/// Assume that it won't oom when creating/mapping.
-impl PageTable {
-    pub fn new() -> Self {
-        let frame = frame_alloc().unwrap();
-        PageTable {
-            root_ppn: frame.ppn,
-            frames: vec![frame],
+/// Assume that it won't oom when creating/mapping.
+impl PageTable {
+    pub fn new() -> Self {
+        let frame = frame_alloc().unwrap();
+        PageTable {
+            root_ppn: frame.ppn,
+            frames: vec![frame],
         }
     }
-    /// Temporarily used to get arguments from user space.
-    pub fn from_token(satp: usize) -> Self {
-        Self {
-            root_ppn: PhysPageNum::from(satp & ((1usize << 44) - 1)),
-            frames: Vec::new(),
+    /// Temporarily used to get arguments from user space.
+    pub fn from_token(satp: usize) -> Self {
+        Self {
+            root_ppn: PhysPageNum::from(satp & ((1usize << 44) - 1)),
+            frames: Vec::new(),
         }
     }
-    fn find_pte_create(&mut self, vpn: VirtPageNum) -> Option<&mut PageTableEntry> {
-        let idxs = vpn.indexes();
-        let mut ppn = self.root_ppn;
-        let mut result: Option<&mut PageTableEntry> = None;
-        for (i, idx) in idxs.iter().enumerate() {
-            let pte = &mut ppn.get_pte_array()[*idx];
-            if i == 2 {
-                result = Some(pte);
+    fn find_pte_create(&mut self, vpn: VirtPageNum) -> Option<&mut PageTableEntry> {
+        let idxs = vpn.indexes();
+        let mut ppn = self.root_ppn;
+        let mut result: Option<&mut PageTableEntry> = None;
+        for (i, idx) in idxs.iter().enumerate() {
+            let pte = &mut ppn.get_pte_array()[*idx];
+            if i == 2 {
+                result = Some(pte);
                 break;
             }
-            if !pte.is_valid() {
-                let frame = frame_alloc().unwrap();
-                *pte = PageTableEntry::new(frame.ppn, PTEFlags::V);
-                self.frames.push(frame);
+            if !pte.is_valid() {
+                let frame = frame_alloc().unwrap();
+                *pte = PageTableEntry::new(frame.ppn, PTEFlags::V);
+                self.frames.push(frame);
             }
-            ppn = pte.ppn();
+            ppn = pte.ppn();
         }
-        result
+        result
     }
-    fn find_pte(&self, vpn: VirtPageNum) -> Option<&mut PageTableEntry> {
-        let idxs = vpn.indexes();
-        let mut ppn = self.root_ppn;
-        let mut result: Option<&mut PageTableEntry> = None;
-        for (i, idx) in idxs.iter().enumerate() {
-            let pte = &mut ppn.get_pte_array()[*idx];
-            if i == 2 {
-                result = Some(pte);
+    fn find_pte(&self, vpn: VirtPageNum) -> Option<&mut PageTableEntry> {
+        let idxs = vpn.indexes();
+        let mut ppn = self.root_ppn;
+        let mut result: Option<&mut PageTableEntry> = None;
+        for (i, idx) in idxs.iter().enumerate() {
+            let pte = &mut ppn.get_pte_array()[*idx];
+            if i == 2 {
+                result = Some(pte);
                 break;
             }
-            if !pte.is_valid() {
-                return None;
+            if !pte.is_valid() {
+                return None;
             }
-            ppn = pte.ppn();
+            ppn = pte.ppn();
         }
-        result
+        result
     }
-    #[allow(unused)]
-    pub fn map(&mut self, vpn: VirtPageNum, ppn: PhysPageNum, flags: PTEFlags) {
-        let pte = self.find_pte_create(vpn).unwrap();
-        assert!(!pte.is_valid(), "vpn {:?} is mapped before mapping", vpn);
-        *pte = PageTableEntry::new(ppn, flags | PTEFlags::V);
+    #[allow(unused)]
+    pub fn map(&mut self, vpn: VirtPageNum, ppn: PhysPageNum, flags: PTEFlags) {
+        let pte = self.find_pte_create(vpn).unwrap();
+        assert!(!pte.is_valid(), "vpn {:?} is mapped before mapping", vpn);
+        *pte = PageTableEntry::new(ppn, flags | PTEFlags::V);
     }
-    #[allow(unused)]
-    pub fn unmap(&mut self, vpn: VirtPageNum) {
-        let pte = self.find_pte(vpn).unwrap();
-        assert!(pte.is_valid(), "vpn {:?} is invalid before unmapping", vpn);
-        *pte = PageTableEntry::empty();
+    #[allow(unused)]
+    pub fn unmap(&mut self, vpn: VirtPageNum) {
+        let pte = self.find_pte(vpn).unwrap();
+        assert!(pte.is_valid(), "vpn {:?} is invalid before unmapping", vpn);
+        *pte = PageTableEntry::empty();
     }
-    pub fn translate(&self, vpn: VirtPageNum) -> Option<PageTableEntry> {
-        self.find_pte(vpn).map(|pte| *pte)
+    pub fn translate(&self, vpn: VirtPageNum) -> Option<PageTableEntry> {
+        self.find_pte(vpn).map(|pte| *pte)
     }
-    pub fn translate_va(&self, va: VirtAddr) -> Option<PhysAddr> {
-        self.find_pte(va.clone().floor()).map(|pte| {
-            //println!("translate_va:va = {:?}", va);
-            let aligned_pa: PhysAddr = pte.ppn().into();
-            //println!("translate_va:pa_align = {:?}", aligned_pa);
-            let offset = va.page_offset();
-            let aligned_pa_usize: usize = aligned_pa.into();
-            (aligned_pa_usize + offset).into()
+    pub fn translate_va(&self, va: VirtAddr) -> Option<PhysAddr> {
+        self.find_pte(va.clone().floor()).map(|pte| {
+            //println!("translate_va:va = {:?}", va);
+            let aligned_pa: PhysAddr = pte.ppn().into();
+            //println!("translate_va:pa_align = {:?}", aligned_pa);
+            let offset = va.page_offset();
+            let aligned_pa_usize: usize = aligned_pa.into();
+            (aligned_pa_usize + offset).into()
         })
     }
-    pub fn token(&self) -> usize {
-        8usize << 60 | self.root_ppn.0
-    }
+    pub fn token(&self) -> usize {
+        8usize << 60 | self.root_ppn.0
+    }
 }
-/// translate a pointer to a mutable u8 Vec through page table
-pub fn translated_byte_buffer(token: usize, ptr: *const u8, len: usize) -> Vec<&'static mut [u8]> {
-    let page_table = PageTable::from_token(token);
-    let mut start = ptr as usize;
-    let end = start + len;
-    let mut v = Vec::new();
-    while start < end {
-        let start_va = VirtAddr::from(start);
-        let mut vpn = start_va.floor();
-        let ppn = page_table.translate(vpn).unwrap().ppn();
-        vpn.step();
-        let mut end_va: VirtAddr = vpn.into();
-        end_va = end_va.min(VirtAddr::from(end));
-        if end_va.page_offset() == 0 {
-            v.push(&mut ppn.get_bytes_array()[start_va.page_offset()..]);
-        } else {
-            v.push(&mut ppn.get_bytes_array()[start_va.page_offset()..end_va.page_offset()]);
+/// translate a pointer to a mutable u8 Vec through page table
+pub fn translated_byte_buffer(token: usize, ptr: *const u8, len: usize) -> Vec<&'static mut [u8]> {
+    let page_table = PageTable::from_token(token);
+    let mut start = ptr as usize;
+    let end = start + len;
+    let mut v = Vec::new();
+    while start < end {
+        let start_va = VirtAddr::from(start);
+        let mut vpn = start_va.floor();
+        let ppn = page_table.translate(vpn).unwrap().ppn();
+        vpn.step();
+        let mut end_va: VirtAddr = vpn.into();
+        end_va = end_va.min(VirtAddr::from(end));
+        if end_va.page_offset() == 0 {
+            v.push(&mut ppn.get_bytes_array()[start_va.page_offset()..]);
+        } else {
+            v.push(&mut ppn.get_bytes_array()[start_va.page_offset()..end_va.page_offset()]);
         }
-        start = end_va.into();
+        start = end_va.into();
     }
-    v
+    v
 }
-/// translate a pointer to a mutable u8 Vec end with `\0` through page table to a `String`
-pub fn translated_str(token: usize, ptr: *const u8) -> String {
-    let page_table = PageTable::from_token(token);
-    let mut string = String::new();
-    let mut va = ptr as usize;
-    loop {
-        let ch: u8 = *(page_table
-            .translate_va(VirtAddr::from(va))
-            .unwrap()
-            .get_mut());
-        if ch == 0 {
+/// translate a pointer to a mutable u8 Vec end with `\0` through page table to a `String`
+pub fn translated_str(token: usize, ptr: *const u8) -> String {
+    let page_table = PageTable::from_token(token);
+    let mut string = String::new();
+    let mut va = ptr as usize;
+    loop {
+        let ch: u8 = *(page_table
+            .translate_va(VirtAddr::from(va))
+            .unwrap()
+            .get_mut());
+        if ch == 0 {
             break;
-        } else {
-            string.push(ch as char);
-            va += 1;
+        } else {
+            string.push(ch as char);
+            va += 1;
         }
     }
-    string
+    string
 }
-///translate a generic through page table and return a mutable reference
-pub fn translated_refmut<T>(token: usize, ptr: *mut T) -> &'static mut T {
-    //println!("into translated_refmut!");
-    let page_table = PageTable::from_token(token);
-    let va = ptr as usize;
-    //println!("translated_refmut: before translate_va");
-    page_table
-        .translate_va(VirtAddr::from(va))
-        .unwrap()
-        .get_mut()
+///translate a generic through page table and return a mutable reference
+pub fn translated_refmut<T>(token: usize, ptr: *mut T) -> &'static mut T {
+    //println!("into translated_refmut!");
+    let page_table = PageTable::from_token(token);
+    let va = ptr as usize;
+    //println!("translated_refmut: before translate_va");
+    page_table
+        .translate_va(VirtAddr::from(va))
+        .unwrap()
+        .get_mut()
 }
-
    
-
    \ No newline at end of file + \ No newline at end of file diff --git a/ch5/src/os/sbi.rs.html b/ch5/src/os/sbi.rs.html index 1799d7f8..ca251be2 100644 --- a/ch5/src/os/sbi.rs.html +++ b/ch5/src/os/sbi.rs.html @@ -1,62 +1,61 @@ -sbi.rs - source
    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
-
    //! SBI call wrappers
-#![allow(unused)]
+sbi.rs - source
    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
+
    //! SBI call wrappers
+#![allow(unused)]
 
-/// use sbi call to putchar in console (qemu uart handler)
-pub fn console_putchar(c: usize) {
-    #[allow(deprecated)]
-    sbi_rt::legacy::console_putchar(c);
+/// use sbi call to putchar in console (qemu uart handler)
+pub fn console_putchar(c: usize) {
+    #[allow(deprecated)]
+    sbi_rt::legacy::console_putchar(c);
 }
 
-/// use sbi call to getchar from console (qemu uart handler)
-pub fn console_getchar() -> usize {
-    #[allow(deprecated)]
-    sbi_rt::legacy::console_getchar()
+/// use sbi call to getchar from console (qemu uart handler)
+pub fn console_getchar() -> usize {
+    #[allow(deprecated)]
+    sbi_rt::legacy::console_getchar()
 }
 
-/// use sbi call to set timer
-pub fn set_timer(timer: usize) {
-    sbi_rt::set_timer(timer as _);
+/// use sbi call to set timer
+pub fn set_timer(timer: usize) {
+    sbi_rt::set_timer(timer as _);
 }
 
-/// use sbi call to shutdown the kernel
-pub fn shutdown(failure: bool) -> ! {
-    use sbi_rt::{system_reset, NoReason, Shutdown, SystemFailure};
-    if !failure {
-        system_reset(Shutdown, NoReason);
-    } else {
-        system_reset(Shutdown, SystemFailure);
+/// use sbi call to shutdown the kernel
+pub fn shutdown(failure: bool) -> ! {
+    use sbi_rt::{system_reset, NoReason, Shutdown, SystemFailure};
+    if !failure {
+        system_reset(Shutdown, NoReason);
+    } else {
+        system_reset(Shutdown, SystemFailure);
     }
     unreachable!()
 }
-
    
-
    \ No newline at end of file + \ No newline at end of file diff --git a/ch5/src/os/sync/mod.rs.html b/ch5/src/os/sync/mod.rs.html index 1833b02b..89ed0bf7 100644 --- a/ch5/src/os/sync/mod.rs.html +++ b/ch5/src/os/sync/mod.rs.html @@ -1,10 +1,9 @@ -mod.rs - source
    1
-2
-3
-4
-
    //! Synchronization and interior mutability primitives
-mod up;
+mod.rs - source
    1
+2
+3
+4
+
    //! Synchronization and interior mutability primitives
+mod up;
 
-pub use up::UPSafeCell;
-
    
-
    \ No newline at end of file +pub use up::UPSafeCell; + \ No newline at end of file diff --git a/ch5/src/os/sync/up.rs.html b/ch5/src/os/sync/up.rs.html index 66ccab8d..e20054e7 100644 --- a/ch5/src/os/sync/up.rs.html +++ b/ch5/src/os/sync/up.rs.html @@ -1,62 +1,61 @@ -up.rs - source
    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
-
    //! Uniprocessor interior mutability primitives
-use core::cell::{RefCell, RefMut};
+up.rs - source
    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
+
    //! Uniprocessor interior mutability primitives
+use core::cell::{RefCell, RefMut};
 
-/// Wrap a static data structure inside it so that we are
-/// able to access it without any `unsafe`.
-///
-/// We should only use it in uniprocessor.
-///
-/// In order to get mutable reference of inner data, call
-/// `exclusive_access`.
-pub struct UPSafeCell<T> {
-    /// inner data
-    inner: RefCell<T>,
+/// Wrap a static data structure inside it so that we are
+/// able to access it without any `unsafe`.
+///
+/// We should only use it in uniprocessor.
+///
+/// In order to get mutable reference of inner data, call
+/// `exclusive_access`.
+pub struct UPSafeCell<T> {
+    /// inner data
+    inner: RefCell<T>,
 }
 
-unsafe impl<T> Sync for UPSafeCell<T> {}
+unsafe impl<T> Sync for UPSafeCell<T> {}
 
-impl<T> UPSafeCell<T> {
-    /// User is responsible to guarantee that inner struct is only used in
-    /// uniprocessor.
-    pub unsafe fn new(value: T) -> Self {
-        Self {
-            inner: RefCell::new(value),
+impl<T> UPSafeCell<T> {
+    /// User is responsible to guarantee that inner struct is only used in
+    /// uniprocessor.
+    pub unsafe fn new(value: T) -> Self {
+        Self {
+            inner: RefCell::new(value),
         }
     }
-    /// Exclusive access inner data in UPSafeCell. Panic if the data has been borrowed.
-    pub fn exclusive_access(&self) -> RefMut<'_, T> {
-        self.inner.borrow_mut()
+    /// Exclusive access inner data in UPSafeCell. Panic if the data has been borrowed.
+    pub fn exclusive_access(&self) -> RefMut<'_, T> {
+        self.inner.borrow_mut()
     }
 }
-
    
-
    \ No newline at end of file + \ No newline at end of file diff --git a/ch5/src/os/syscall/fs.rs.html b/ch5/src/os/syscall/fs.rs.html index 202d4d95..ca7ddf0a 100644 --- a/ch5/src/os/syscall/fs.rs.html +++ b/ch5/src/os/syscall/fs.rs.html @@ -1,100 +1,99 @@ -fs.rs - source
    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
-
    //! File and filesystem-related syscalls
-use crate::mm::translated_byte_buffer;
-use crate::sbi::console_getchar;
-use crate::task::{current_user_token, suspend_current_and_run_next};
+fs.rs - source
    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
+
    //! File and filesystem-related syscalls
+use crate::mm::translated_byte_buffer;
+use crate::sbi::console_getchar;
+use crate::task::{current_user_token, suspend_current_and_run_next};
 
-const FD_STDIN: usize = 0;
-const FD_STDOUT: usize = 1;
+const FD_STDIN: usize = 0;
+const FD_STDOUT: usize = 1;
 
-pub fn sys_write(fd: usize, buf: *const u8, len: usize) -> isize {
-    match fd {
-        FD_STDOUT => {
-            let buffers = translated_byte_buffer(current_user_token(), buf, len);
-            for buffer in buffers {
-                print!("{}", core::str::from_utf8(buffer).unwrap());
+pub fn sys_write(fd: usize, buf: *const u8, len: usize) -> isize {
+    match fd {
+        FD_STDOUT => {
+            let buffers = translated_byte_buffer(current_user_token(), buf, len);
+            for buffer in buffers {
+                print!("{}", core::str::from_utf8(buffer).unwrap());
             }
-            len as isize
+            len as isize
         }
-        _ => {
+        _ => {
             panic!("Unsupported fd in sys_write!");
         }
     }
 }
 
-pub fn sys_read(fd: usize, buf: *const u8, len: usize) -> isize {
-    match fd {
-        FD_STDIN => {
-            assert_eq!(len, 1, "Only support len = 1 in sys_read!");
-            let mut c: usize;
-            loop {
-                c = console_getchar();
-                if c == 0 {
-                    suspend_current_and_run_next();
+pub fn sys_read(fd: usize, buf: *const u8, len: usize) -> isize {
+    match fd {
+        FD_STDIN => {
+            assert_eq!(len, 1, "Only support len = 1 in sys_read!");
+            let mut c: usize;
+            loop {
+                c = console_getchar();
+                if c == 0 {
+                    suspend_current_and_run_next();
                     continue;
-                } else {
+                } else {
                     break;
                 }
             }
-            let ch = c as u8;
-            let mut buffers = translated_byte_buffer(current_user_token(), buf, len);
-            unsafe {
-                buffers[0].as_mut_ptr().write_volatile(ch);
+            let ch = c as u8;
+            let mut buffers = translated_byte_buffer(current_user_token(), buf, len);
+            unsafe {
+                buffers[0].as_mut_ptr().write_volatile(ch);
             }
-            1
-        }
-        _ => {
+            1
+        }
+        _ => {
             panic!("Unsupported fd in sys_read!");
         }
     }
 }
-
    
-
    \ No newline at end of file + \ No newline at end of file diff --git a/ch5/src/os/syscall/mod.rs.html b/ch5/src/os/syscall/mod.rs.html index 8db5ced3..926d879e 100644 --- a/ch5/src/os/syscall/mod.rs.html +++ b/ch5/src/os/syscall/mod.rs.html @@ -1,84 +1,83 @@ -mod.rs - source
    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
-
    //! Implementation of syscalls
-//!
-//! The single entry point to all system calls, [`syscall()`], is called
-//! whenever userspace wishes to perform a system call using the `ecall`
-//! instruction. In this case, the processor raises an 'Environment call from
-//! U-mode' exception, which is handled as one of the cases in
-//! [`crate::trap::trap_handler`].
-//!
-//! For clarity, each single syscall is implemented as its own function, named
-//! `sys_` then the name of the syscall. You can find functions like this in
-//! submodules, and you should also implement syscalls this way.
-const SYSCALL_READ: usize = 63;
-const SYSCALL_WRITE: usize = 64;
-const SYSCALL_EXIT: usize = 93;
-const SYSCALL_YIELD: usize = 124;
-const SYSCALL_GET_TIME: usize = 169;
-const SYSCALL_GETPID: usize = 172;
-const SYSCALL_FORK: usize = 220;
-const SYSCALL_EXEC: usize = 221;
-const SYSCALL_WAITPID: usize = 260;
+mod.rs - source
    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
+
    //! Implementation of syscalls
+//!
+//! The single entry point to all system calls, [`syscall()`], is called
+//! whenever userspace wishes to perform a system call using the `ecall`
+//! instruction. In this case, the processor raises an 'Environment call from
+//! U-mode' exception, which is handled as one of the cases in
+//! [`crate::trap::trap_handler`].
+//!
+//! For clarity, each single syscall is implemented as its own function, named
+//! `sys_` then the name of the syscall. You can find functions like this in
+//! submodules, and you should also implement syscalls this way.
+const SYSCALL_READ: usize = 63;
+const SYSCALL_WRITE: usize = 64;
+const SYSCALL_EXIT: usize = 93;
+const SYSCALL_YIELD: usize = 124;
+const SYSCALL_GET_TIME: usize = 169;
+const SYSCALL_GETPID: usize = 172;
+const SYSCALL_FORK: usize = 220;
+const SYSCALL_EXEC: usize = 221;
+const SYSCALL_WAITPID: usize = 260;
 
-mod fs;
-mod process;
+mod fs;
+mod process;
 
-use fs::*;
-use process::*;
-/// handle syscall exception with `syscall_id` and other arguments
-pub fn syscall(syscall_id: usize, args: [usize; 3]) -> isize {
-    match syscall_id {
-        SYSCALL_READ => sys_read(args[0], args[1] as *const u8, args[2]),
-        SYSCALL_WRITE => sys_write(args[0], args[1] as *const u8, args[2]),
-        SYSCALL_EXIT => sys_exit(args[0] as i32),
-        SYSCALL_YIELD => sys_yield(),
-        SYSCALL_GET_TIME => sys_get_time(),
-        SYSCALL_GETPID => sys_getpid(),
-        SYSCALL_FORK => sys_fork(),
-        SYSCALL_EXEC => sys_exec(args[0] as *const u8),
-        SYSCALL_WAITPID => sys_waitpid(args[0] as isize, args[1] as *mut i32),
-        _ => panic!("Unsupported syscall_id: {}", syscall_id),
+use fs::*;
+use process::*;
+/// handle syscall exception with `syscall_id` and other arguments
+pub fn syscall(syscall_id: usize, args: [usize; 3]) -> isize {
+    match syscall_id {
+        SYSCALL_READ => sys_read(args[0], args[1] as *const u8, args[2]),
+        SYSCALL_WRITE => sys_write(args[0], args[1] as *const u8, args[2]),
+        SYSCALL_EXIT => sys_exit(args[0] as i32),
+        SYSCALL_YIELD => sys_yield(),
+        SYSCALL_GET_TIME => sys_get_time(),
+        SYSCALL_GETPID => sys_getpid(),
+        SYSCALL_FORK => sys_fork(),
+        SYSCALL_EXEC => sys_exec(args[0] as *const u8),
+        SYSCALL_WAITPID => sys_waitpid(args[0] as isize, args[1] as *mut i32),
+        _ => panic!("Unsupported syscall_id: {}", syscall_id),
     }
 }
-
    
-
    \ No newline at end of file + \ No newline at end of file diff --git a/ch5/src/os/syscall/process.rs.html b/ch5/src/os/syscall/process.rs.html index 5c0a25f6..6b9d51da 100644 --- a/ch5/src/os/syscall/process.rs.html +++ b/ch5/src/os/syscall/process.rs.html @@ -1,180 +1,179 @@ -process.rs - source
    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
-
    use crate::loader::get_app_data_by_name;
-use crate::mm::{translated_refmut, translated_str};
-use crate::task::{
-    add_task, current_task, current_user_token, exit_current_and_run_next,
-    suspend_current_and_run_next,
+process.rs - source
    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
+
    use crate::loader::get_app_data_by_name;
+use crate::mm::{translated_refmut, translated_str};
+use crate::task::{
+    add_task, current_task, current_user_token, exit_current_and_run_next,
+    suspend_current_and_run_next,
 };
-use crate::timer::get_time_ms;
-use alloc::sync::Arc;
+use crate::timer::get_time_ms;
+use alloc::sync::Arc;
 
-pub fn sys_exit(exit_code: i32) -> ! {
-    exit_current_and_run_next(exit_code);
+pub fn sys_exit(exit_code: i32) -> ! {
+    exit_current_and_run_next(exit_code);
     panic!("Unreachable in sys_exit!");
 }
 
-pub fn sys_yield() -> isize {
-    suspend_current_and_run_next();
-    0
+pub fn sys_yield() -> isize {
+    suspend_current_and_run_next();
+    0
+}
+
+pub fn sys_get_time() -> isize {
+    get_time_ms() as isize
 }
 
-pub fn sys_get_time() -> isize {
-    get_time_ms() as isize
+pub fn sys_getpid() -> isize {
+    current_task().unwrap().pid.0 as isize
 }
 
-pub fn sys_getpid() -> isize {
-    current_task().unwrap().pid.0 as isize
+pub fn sys_fork() -> isize {
+    let current_task = current_task().unwrap();
+    let new_task = current_task.fork();
+    let new_pid = new_task.pid.0;
+    // modify trap context of new_task, because it returns immediately after switching
+    let trap_cx = new_task.inner_exclusive_access().get_trap_cx();
+    // we do not have to move to next instruction since we have done it before
+    // for child process, fork returns 0
+    trap_cx.x[10] = 0;
+    // add new task to scheduler
+    add_task(new_task);
+    new_pid as isize
 }
 
-pub fn sys_fork() -> isize {
-    let current_task = current_task().unwrap();
-    let new_task = current_task.fork();
-    let new_pid = new_task.pid.0;
-    // modify trap context of new_task, because it returns immediately after switching
-    let trap_cx = new_task.inner_exclusive_access().get_trap_cx();
-    // we do not have to move to next instruction since we have done it before
-    // for child process, fork returns 0
-    trap_cx.x[10] = 0;
-    // add new task to scheduler
-    add_task(new_task);
-    new_pid as isize
+pub fn sys_exec(path: *const u8) -> isize {
+    let token = current_user_token();
+    let path = translated_str(token, path);
+    if let Some(data) = get_app_data_by_name(path.as_str()) {
+        let task = current_task().unwrap();
+        task.exec(data);
+        0
+    } else {
+        -1
+    }
 }
 
-pub fn sys_exec(path: *const u8) -> isize {
-    let token = current_user_token();
-    let path = translated_str(token, path);
-    if let Some(data) = get_app_data_by_name(path.as_str()) {
-        let task = current_task().unwrap();
-        task.exec(data);
-        0
-    } else {
-        -1
-    }
-}
+/// If there is not a child process whose pid is same as given, return -1.
+/// Else if there is a child process but it is still running, return -2.
+pub fn sys_waitpid(pid: isize, exit_code_ptr: *mut i32) -> isize {
+    let task = current_task().unwrap();
+    // find a child process
 
-/// If there is not a child process whose pid is same as given, return -1.
-/// Else if there is a child process but it is still running, return -2.
-pub fn sys_waitpid(pid: isize, exit_code_ptr: *mut i32) -> isize {
-    let task = current_task().unwrap();
-    // find a child process
-
-    // ---- access current TCB exclusively
-    let mut inner = task.inner_exclusive_access();
-    if !inner
-        .children
-        .iter()
-        .any(|p| pid == -1 || pid as usize == p.getpid())
+    // ---- access current TCB exclusively
+    let mut inner = task.inner_exclusive_access();
+    if !inner
+        .children
+        .iter()
+        .any(|p| pid == -1 || pid as usize == p.getpid())
     {
-        return -1;
-        // ---- release current PCB
-    }
-    let pair = inner.children.iter().enumerate().find(|(_, p)| {
-        // ++++ temporarily access child PCB lock exclusively
-        p.inner_exclusive_access().is_zombie() && (pid == -1 || pid as usize == p.getpid())
-        // ++++ release child PCB
-    });
-    if let Some((idx, _)) = pair {
-        let child = inner.children.remove(idx);
-        // confirm that child will be deallocated after removing from children list
-        assert_eq!(Arc::strong_count(&child), 1);
-        let found_pid = child.getpid();
-        // ++++ temporarily access child TCB exclusively
-        let exit_code = child.inner_exclusive_access().exit_code;
-        // ++++ release child PCB
-        *translated_refmut(inner.memory_set.token(), exit_code_ptr) = exit_code;
-        found_pid as isize
-    } else {
-        -2
-    }
-    // ---- release current PCB lock automatically
-}
-
    
-
    \ No newline at end of file + return -1; + // ---- release current PCB + } + let pair = inner.children.iter().enumerate().find(|(_, p)| { + // ++++ temporarily access child PCB lock exclusively + p.inner_exclusive_access().is_zombie() && (pid == -1 || pid as usize == p.getpid()) + // ++++ release child PCB + }); + if let Some((idx, _)) = pair { + let child = inner.children.remove(idx); + // confirm that child will be deallocated after removing from children list + assert_eq!(Arc::strong_count(&child), 1); + let found_pid = child.getpid(); + // ++++ temporarily access child TCB exclusively + let exit_code = child.inner_exclusive_access().exit_code; + // ++++ release child PCB + *translated_refmut(inner.memory_set.token(), exit_code_ptr) = exit_code; + found_pid as isize + } else { + -2 + } + // ---- release current PCB lock automatically +} + \ No newline at end of file diff --git a/ch5/src/os/task/context.rs.html b/ch5/src/os/task/context.rs.html index d9e65cf1..f6f78874 100644 --- a/ch5/src/os/task/context.rs.html +++ b/ch5/src/os/task/context.rs.html @@ -1,66 +1,65 @@ -context.rs - source
    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
-
    //! Implementation of [`TaskContext`]
-use crate::trap::trap_return;
+context.rs - source
    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
+
    //! Implementation of [`TaskContext`]
+use crate::trap::trap_return;
 
-#[repr(C)]
-/// task context structure containing some registers
-pub struct TaskContext {
-    /// return address ( e.g. __restore ) of __switch ASM function
-    ra: usize,
-    /// kernel stack pointer of app
-    sp: usize,
-    /// s0-11 register, callee saved
-    s: [usize; 12],
+#[repr(C)]
+/// task context structure containing some registers
+pub struct TaskContext {
+    /// return address ( e.g. __restore ) of __switch ASM function
+    ra: usize,
+    /// kernel stack pointer of app
+    sp: usize,
+    /// s0-11 register, callee saved
+    s: [usize; 12],
 }
 
-impl TaskContext {
-    /// init task context
-    pub fn zero_init() -> Self {
-        Self {
-            ra: 0,
-            sp: 0,
-            s: [0; 12],
+impl TaskContext {
+    /// init task context
+    pub fn zero_init() -> Self {
+        Self {
+            ra: 0,
+            sp: 0,
+            s: [0; 12],
         }
     }
-    /// set Task Context{__restore ASM funciton: trap_return, sp: kstack_ptr, s: s_0..12}
-    pub fn goto_trap_return(kstack_ptr: usize) -> Self {
-        Self {
-            ra: trap_return as usize,
-            sp: kstack_ptr,
-            s: [0; 12],
+    /// set Task Context{__restore ASM funciton: trap_return, sp: kstack_ptr, s: s_0..12}
+    pub fn goto_trap_return(kstack_ptr: usize) -> Self {
+        Self {
+            ra: trap_return as usize,
+            sp: kstack_ptr,
+            s: [0; 12],
         }
     }
 }
-
    
-
    \ No newline at end of file + \ No newline at end of file diff --git a/ch5/src/os/task/manager.rs.html b/ch5/src/os/task/manager.rs.html index 71a3185a..47b41f43 100644 --- a/ch5/src/os/task/manager.rs.html +++ b/ch5/src/os/task/manager.rs.html @@ -1,84 +1,83 @@ -manager.rs - source
    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
-
    //!Implementation of [`TaskManager`]
-use super::TaskControlBlock;
-use crate::sync::UPSafeCell;
-use alloc::collections::VecDeque;
-use alloc::sync::Arc;
-use lazy_static::*;
-///A array of `TaskControlBlock` that is thread-safe
-pub struct TaskManager {
-    ready_queue: VecDeque<Arc<TaskControlBlock>>,
+manager.rs - source
    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
+
    //!Implementation of [`TaskManager`]
+use super::TaskControlBlock;
+use crate::sync::UPSafeCell;
+use alloc::collections::VecDeque;
+use alloc::sync::Arc;
+use lazy_static::*;
+///A array of `TaskControlBlock` that is thread-safe
+pub struct TaskManager {
+    ready_queue: VecDeque<Arc<TaskControlBlock>>,
 }
 
-/// A simple FIFO scheduler.
-impl TaskManager {
-    ///Creat an empty TaskManager
-    pub fn new() -> Self {
-        Self {
-            ready_queue: VecDeque::new(),
+/// A simple FIFO scheduler.
+impl TaskManager {
+    ///Creat an empty TaskManager
+    pub fn new() -> Self {
+        Self {
+            ready_queue: VecDeque::new(),
         }
     }
-    ///Add a task to `TaskManager`
-    pub fn add(&mut self, task: Arc<TaskControlBlock>) {
-        self.ready_queue.push_back(task);
+    ///Add a task to `TaskManager`
+    pub fn add(&mut self, task: Arc<TaskControlBlock>) {
+        self.ready_queue.push_back(task);
     }
-    ///Remove the first task and return it,or `None` if `TaskManager` is empty
-    pub fn fetch(&mut self) -> Option<Arc<TaskControlBlock>> {
-        self.ready_queue.pop_front()
+    ///Remove the first task and return it,or `None` if `TaskManager` is empty
+    pub fn fetch(&mut self) -> Option<Arc<TaskControlBlock>> {
+        self.ready_queue.pop_front()
     }
 }
 
-lazy_static! {
-    pub static ref TASK_MANAGER: UPSafeCell<TaskManager> =
-        unsafe { UPSafeCell::new(TaskManager::new()) };
+lazy_static! {
+    pub static ref TASK_MANAGER: UPSafeCell<TaskManager> =
+        unsafe { UPSafeCell::new(TaskManager::new()) };
 }
-///Interface offered to add task
-pub fn add_task(task: Arc<TaskControlBlock>) {
-    TASK_MANAGER.exclusive_access().add(task);
+///Interface offered to add task
+pub fn add_task(task: Arc<TaskControlBlock>) {
+    TASK_MANAGER.exclusive_access().add(task);
 }
-///Interface offered to pop the first task
-pub fn fetch_task() -> Option<Arc<TaskControlBlock>> {
-    TASK_MANAGER.exclusive_access().fetch()
+///Interface offered to pop the first task
+pub fn fetch_task() -> Option<Arc<TaskControlBlock>> {
+    TASK_MANAGER.exclusive_access().fetch()
 }
-
    
-
    \ No newline at end of file + \ No newline at end of file diff --git a/ch5/src/os/task/mod.rs.html b/ch5/src/os/task/mod.rs.html index b264e91d..cd9ea6da 100644 --- a/ch5/src/os/task/mod.rs.html +++ b/ch5/src/os/task/mod.rs.html @@ -1,244 +1,243 @@ -mod.rs - source
    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
-
    //! Task management implementation
-//!
-//! Everything about task management, like starting and switching tasks is
-//! implemented here.
-//!
-//! A single global instance of [`TaskManager`] called `TASK_MANAGER` controls
-//! all the tasks in the whole operating system.
-//!
-//! A single global instance of [`Processor`] called `PROCESSOR` monitors running
-//! task(s) for each core.
-//!
-//! A single global instance of [`PidAllocator`] called `PID_ALLOCATOR` allocates
-//! pid for user apps.
-//!
-//! Be careful when you see `__switch` ASM function in `switch.S`. Control flow around this function
-//! might not be what you expect.
-mod context;
-mod manager;
-mod pid;
-mod processor;
-mod switch;
-#[allow(clippy::module_inception)]
-mod task;
+mod.rs - source
    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
+
    //! Task management implementation
+//!
+//! Everything about task management, like starting and switching tasks is
+//! implemented here.
+//!
+//! A single global instance of [`TaskManager`] called `TASK_MANAGER` controls
+//! all the tasks in the whole operating system.
+//!
+//! A single global instance of [`Processor`] called `PROCESSOR` monitors running
+//! task(s) for each core.
+//!
+//! A single global instance of [`PidAllocator`] called `PID_ALLOCATOR` allocates
+//! pid for user apps.
+//!
+//! Be careful when you see `__switch` ASM function in `switch.S`. Control flow around this function
+//! might not be what you expect.
+mod context;
+mod manager;
+mod pid;
+mod processor;
+mod switch;
+#[allow(clippy::module_inception)]
+mod task;
 
-use crate::loader::get_app_data_by_name;
-use crate::sbi::shutdown;
-use alloc::sync::Arc;
-use lazy_static::*;
-pub use manager::{fetch_task, TaskManager};
-use switch::__switch;
-use task::{TaskControlBlock, TaskStatus};
+use crate::loader::get_app_data_by_name;
+use crate::sbi::shutdown;
+use alloc::sync::Arc;
+use lazy_static::*;
+pub use manager::{fetch_task, TaskManager};
+use switch::__switch;
+use task::{TaskControlBlock, TaskStatus};
 
-pub use context::TaskContext;
-pub use manager::add_task;
-pub use pid::{pid_alloc, KernelStack, PidAllocator, PidHandle};
-pub use processor::{
-    current_task, current_trap_cx, current_user_token, run_tasks, schedule, take_current_task,
-    Processor,
+pub use context::TaskContext;
+pub use manager::add_task;
+pub use pid::{pid_alloc, KernelStack, PidAllocator, PidHandle};
+pub use processor::{
+    current_task, current_trap_cx, current_user_token, run_tasks, schedule, take_current_task,
+    Processor,
 };
-/// Suspend the current 'Running' task and run the next task in task list.
-pub fn suspend_current_and_run_next() {
-    // There must be an application running.
-    let task = take_current_task().unwrap();
+/// Suspend the current 'Running' task and run the next task in task list.
+pub fn suspend_current_and_run_next() {
+    // There must be an application running.
+    let task = take_current_task().unwrap();
 
-    // ---- access current TCB exclusively
-    let mut task_inner = task.inner_exclusive_access();
-    let task_cx_ptr = &mut task_inner.task_cx as *mut TaskContext;
-    // Change status to Ready
-    task_inner.task_status = TaskStatus::Ready;
-    drop(task_inner);
-    // ---- release current PCB
+    // ---- access current TCB exclusively
+    let mut task_inner = task.inner_exclusive_access();
+    let task_cx_ptr = &mut task_inner.task_cx as *mut TaskContext;
+    // Change status to Ready
+    task_inner.task_status = TaskStatus::Ready;
+    drop(task_inner);
+    // ---- release current PCB
 
-    // push back to ready queue.
-    add_task(task);
-    // jump to scheduling cycle
-    schedule(task_cx_ptr);
+    // push back to ready queue.
+    add_task(task);
+    // jump to scheduling cycle
+    schedule(task_cx_ptr);
 }
 
-/// pid of usertests app in make run TEST=1
-pub const IDLE_PID: usize = 0;
+/// pid of usertests app in make run TEST=1
+pub const IDLE_PID: usize = 0;
 
-/// Exit the current 'Running' task and run the next task in task list.
-pub fn exit_current_and_run_next(exit_code: i32) {
-    // take from Processor
-    let task = take_current_task().unwrap();
+/// Exit the current 'Running' task and run the next task in task list.
+pub fn exit_current_and_run_next(exit_code: i32) {
+    // take from Processor
+    let task = take_current_task().unwrap();
 
-    let pid = task.getpid();
-    if pid == IDLE_PID {
+    let pid = task.getpid();
+    if pid == IDLE_PID {
         println!(
             "[kernel] Idle process exit with exit_code {} ...",
-            exit_code
+            exit_code
         );
-        if exit_code != 0 {
-            //crate::sbi::shutdown(255); //255 == -1 for err hint
-            shutdown(true)
-        } else {
-            //crate::sbi::shutdown(0); //0 for success hint
-            shutdown(false)
+        if exit_code != 0 {
+            //crate::sbi::shutdown(255); //255 == -1 for err hint
+            shutdown(true)
+        } else {
+            //crate::sbi::shutdown(0); //0 for success hint
+            shutdown(false)
         }
     }
 
-    // **** access current TCB exclusively
-    let mut inner = task.inner_exclusive_access();
-    // Change status to Zombie
-    inner.task_status = TaskStatus::Zombie;
-    // Record exit code
-    inner.exit_code = exit_code;
-    // do not move to its parent but under initproc
+    // **** access current TCB exclusively
+    let mut inner = task.inner_exclusive_access();
+    // Change status to Zombie
+    inner.task_status = TaskStatus::Zombie;
+    // Record exit code
+    inner.exit_code = exit_code;
+    // do not move to its parent but under initproc
 
-    // ++++++ access initproc TCB exclusively
-    {
-        let mut initproc_inner = INITPROC.inner_exclusive_access();
-        for child in inner.children.iter() {
-            child.inner_exclusive_access().parent = Some(Arc::downgrade(&INITPROC));
-            initproc_inner.children.push(child.clone());
+    // ++++++ access initproc TCB exclusively
+    {
+        let mut initproc_inner = INITPROC.inner_exclusive_access();
+        for child in inner.children.iter() {
+            child.inner_exclusive_access().parent = Some(Arc::downgrade(&INITPROC));
+            initproc_inner.children.push(child.clone());
         }
     }
-    // ++++++ release parent PCB
+    // ++++++ release parent PCB
 
-    inner.children.clear();
-    // deallocate user space
-    inner.memory_set.recycle_data_pages();
-    drop(inner);
-    // **** release current PCB
-    // drop task manually to maintain rc correctly
-    drop(task);
-    // we do not have to save task context
-    let mut _unused = TaskContext::zero_init();
-    schedule(&mut _unused as *mut _);
+    inner.children.clear();
+    // deallocate user space
+    inner.memory_set.recycle_data_pages();
+    drop(inner);
+    // **** release current PCB
+    // drop task manually to maintain rc correctly
+    drop(task);
+    // we do not have to save task context
+    let mut _unused = TaskContext::zero_init();
+    schedule(&mut _unused as *mut _);
 }
 
-lazy_static! {
-    ///Globle process that init user shell
-    pub static ref INITPROC: Arc<TaskControlBlock> = Arc::new(TaskControlBlock::new(
-        get_app_data_by_name("initproc").unwrap()
+lazy_static! {
+    ///Globle process that init user shell
+    pub static ref INITPROC: Arc<TaskControlBlock> = Arc::new(TaskControlBlock::new(
+        get_app_data_by_name("initproc").unwrap()
     ));
 }
-///Add init process to the manager
-pub fn add_initproc() {
-    add_task(INITPROC.clone());
+///Add init process to the manager
+pub fn add_initproc() {
+    add_task(INITPROC.clone());
 }
-
    
-
    \ No newline at end of file + \ No newline at end of file diff --git a/ch5/src/os/task/pid.rs.html b/ch5/src/os/task/pid.rs.html index 4d46c8aa..4d55c2bf 100644 --- a/ch5/src/os/task/pid.rs.html +++ b/ch5/src/os/task/pid.rs.html @@ -1,224 +1,223 @@ -pid.rs - source
    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
-
    //!Implementation of [`PidAllocator`]
-use crate::config::{KERNEL_STACK_SIZE, PAGE_SIZE, TRAMPOLINE};
-use crate::mm::{MapPermission, VirtAddr, KERNEL_SPACE};
-use crate::sync::UPSafeCell;
-use alloc::vec::Vec;
-use lazy_static::*;
-///Pid Allocator struct
-pub struct PidAllocator {
-    current: usize,
-    recycled: Vec<usize>,
+pid.rs - source
    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
+
    //!Implementation of [`PidAllocator`]
+use crate::config::{KERNEL_STACK_SIZE, PAGE_SIZE, TRAMPOLINE};
+use crate::mm::{MapPermission, VirtAddr, KERNEL_SPACE};
+use crate::sync::UPSafeCell;
+use alloc::vec::Vec;
+use lazy_static::*;
+///Pid Allocator struct
+pub struct PidAllocator {
+    current: usize,
+    recycled: Vec<usize>,
 }
 
-impl PidAllocator {
-    ///Create an empty `PidAllocator`
-    pub fn new() -> Self {
-        PidAllocator {
-            current: 0,
-            recycled: Vec::new(),
+impl PidAllocator {
+    ///Create an empty `PidAllocator`
+    pub fn new() -> Self {
+        PidAllocator {
+            current: 0,
+            recycled: Vec::new(),
         }
     }
-    ///Allocate a pid
-    pub fn alloc(&mut self) -> PidHandle {
-        if let Some(pid) = self.recycled.pop() {
-            PidHandle(pid)
-        } else {
-            self.current += 1;
-            PidHandle(self.current - 1)
+    ///Allocate a pid
+    pub fn alloc(&mut self) -> PidHandle {
+        if let Some(pid) = self.recycled.pop() {
+            PidHandle(pid)
+        } else {
+            self.current += 1;
+            PidHandle(self.current - 1)
         }
     }
-    ///Recycle a pid
-    pub fn dealloc(&mut self, pid: usize) {
-        assert!(pid < self.current);
+    ///Recycle a pid
+    pub fn dealloc(&mut self, pid: usize) {
+        assert!(pid < self.current);
         assert!(
-            !self.recycled.iter().any(|ppid| *ppid == pid),
+            !self.recycled.iter().any(|ppid| *ppid == pid),
             "pid {} has been deallocated!",
-            pid
+            pid
         );
-        self.recycled.push(pid);
+        self.recycled.push(pid);
     }
 }
 
-lazy_static! {
-    pub static ref PID_ALLOCATOR: UPSafeCell<PidAllocator> =
-        unsafe { UPSafeCell::new(PidAllocator::new()) };
+lazy_static! {
+    pub static ref PID_ALLOCATOR: UPSafeCell<PidAllocator> =
+        unsafe { UPSafeCell::new(PidAllocator::new()) };
 }
-///Bind pid lifetime to `PidHandle`
-pub struct PidHandle(pub usize);
+///Bind pid lifetime to `PidHandle`
+pub struct PidHandle(pub usize);
 
-impl Drop for PidHandle {
-    fn drop(&mut self) {
-        //println!("drop pid {}", self.0);
-        PID_ALLOCATOR.exclusive_access().dealloc(self.0);
+impl Drop for PidHandle {
+    fn drop(&mut self) {
+        //println!("drop pid {}", self.0);
+        PID_ALLOCATOR.exclusive_access().dealloc(self.0);
     }
 }
-///Allocate a pid from PID_ALLOCATOR
-pub fn pid_alloc() -> PidHandle {
-    PID_ALLOCATOR.exclusive_access().alloc()
+///Allocate a pid from PID_ALLOCATOR
+pub fn pid_alloc() -> PidHandle {
+    PID_ALLOCATOR.exclusive_access().alloc()
 }
 
-/// Return (bottom, top) of a kernel stack in kernel space.
-pub fn kernel_stack_position(app_id: usize) -> (usize, usize) {
-    let top = TRAMPOLINE - app_id * (KERNEL_STACK_SIZE + PAGE_SIZE);
-    let bottom = top - KERNEL_STACK_SIZE;
-    (bottom, top)
+/// Return (bottom, top) of a kernel stack in kernel space.
+pub fn kernel_stack_position(app_id: usize) -> (usize, usize) {
+    let top = TRAMPOLINE - app_id * (KERNEL_STACK_SIZE + PAGE_SIZE);
+    let bottom = top - KERNEL_STACK_SIZE;
+    (bottom, top)
 }
-///Kernelstack for app
-pub struct KernelStack {
-    pid: usize,
+///Kernelstack for app
+pub struct KernelStack {
+    pid: usize,
 }
 
-impl KernelStack {
-    ///Create a kernelstack from pid
-    pub fn new(pid_handle: &PidHandle) -> Self {
-        let pid = pid_handle.0;
-        let (kernel_stack_bottom, kernel_stack_top) = kernel_stack_position(pid);
-        KERNEL_SPACE.exclusive_access().insert_framed_area(
-            kernel_stack_bottom.into(),
-            kernel_stack_top.into(),
-            MapPermission::R | MapPermission::W,
+impl KernelStack {
+    ///Create a kernelstack from pid
+    pub fn new(pid_handle: &PidHandle) -> Self {
+        let pid = pid_handle.0;
+        let (kernel_stack_bottom, kernel_stack_top) = kernel_stack_position(pid);
+        KERNEL_SPACE.exclusive_access().insert_framed_area(
+            kernel_stack_bottom.into(),
+            kernel_stack_top.into(),
+            MapPermission::R | MapPermission::W,
         );
-        KernelStack { pid: pid_handle.0 }
+        KernelStack { pid: pid_handle.0 }
     }
-    #[allow(unused)]
-    ///Push a value on top of kernelstack
-    pub fn push_on_top<T>(&self, value: T) -> *mut T
-    where
-        T: Sized,
+    #[allow(unused)]
+    ///Push a value on top of kernelstack
+    pub fn push_on_top<T>(&self, value: T) -> *mut T
+    where
+        T: Sized,
     {
-        let kernel_stack_top = self.get_top();
-        let ptr_mut = (kernel_stack_top - core::mem::size_of::<T>()) as *mut T;
-        unsafe {
-            *ptr_mut = value;
+        let kernel_stack_top = self.get_top();
+        let ptr_mut = (kernel_stack_top - core::mem::size_of::<T>()) as *mut T;
+        unsafe {
+            *ptr_mut = value;
         }
-        ptr_mut
+        ptr_mut
     }
-    ///Get the value on the top of kernelstack
-    pub fn get_top(&self) -> usize {
-        let (_, kernel_stack_top) = kernel_stack_position(self.pid);
-        kernel_stack_top
+    ///Get the value on the top of kernelstack
+    pub fn get_top(&self) -> usize {
+        let (_, kernel_stack_top) = kernel_stack_position(self.pid);
+        kernel_stack_top
     }
 }
 
-impl Drop for KernelStack {
-    fn drop(&mut self) {
-        let (kernel_stack_bottom, _) = kernel_stack_position(self.pid);
-        let kernel_stack_bottom_va: VirtAddr = kernel_stack_bottom.into();
-        KERNEL_SPACE
-            .exclusive_access()
-            .remove_area_with_start_vpn(kernel_stack_bottom_va.into());
+impl Drop for KernelStack {
+    fn drop(&mut self) {
+        let (kernel_stack_bottom, _) = kernel_stack_position(self.pid);
+        let kernel_stack_bottom_va: VirtAddr = kernel_stack_bottom.into();
+        KERNEL_SPACE
+            .exclusive_access()
+            .remove_area_with_start_vpn(kernel_stack_bottom_va.into());
     }
 }
-
    
-
    \ No newline at end of file + \ No newline at end of file diff --git a/ch5/src/os/task/processor.rs.html b/ch5/src/os/task/processor.rs.html index 078d5746..39c529dc 100644 --- a/ch5/src/os/task/processor.rs.html +++ b/ch5/src/os/task/processor.rs.html @@ -1,188 +1,187 @@ -processor.rs - source
    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
-
    //!Implementation of [`Processor`] and Intersection of control flow
-use super::__switch;
-use super::{fetch_task, TaskStatus};
-use super::{TaskContext, TaskControlBlock};
-use crate::sync::UPSafeCell;
-use crate::trap::TrapContext;
-use alloc::sync::Arc;
-use lazy_static::*;
-///Processor management structure
-pub struct Processor {
-    ///The task currently executing on the current processor
-    current: Option<Arc<TaskControlBlock>>,
-    ///The basic control flow of each core, helping to select and switch process
-    idle_task_cx: TaskContext,
+processor.rs - source
    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
+
    //!Implementation of [`Processor`] and Intersection of control flow
+use super::__switch;
+use super::{fetch_task, TaskStatus};
+use super::{TaskContext, TaskControlBlock};
+use crate::sync::UPSafeCell;
+use crate::trap::TrapContext;
+use alloc::sync::Arc;
+use lazy_static::*;
+///Processor management structure
+pub struct Processor {
+    ///The task currently executing on the current processor
+    current: Option<Arc<TaskControlBlock>>,
+    ///The basic control flow of each core, helping to select and switch process
+    idle_task_cx: TaskContext,
 }
 
-impl Processor {
-    ///Create an empty Processor
-    pub fn new() -> Self {
-        Self {
-            current: None,
-            idle_task_cx: TaskContext::zero_init(),
+impl Processor {
+    ///Create an empty Processor
+    pub fn new() -> Self {
+        Self {
+            current: None,
+            idle_task_cx: TaskContext::zero_init(),
         }
     }
-    ///Get mutable reference to `idle_task_cx`
-    fn get_idle_task_cx_ptr(&mut self) -> *mut TaskContext {
-        &mut self.idle_task_cx as *mut _
+    ///Get mutable reference to `idle_task_cx`
+    fn get_idle_task_cx_ptr(&mut self) -> *mut TaskContext {
+        &mut self.idle_task_cx as *mut _
+    }
+    ///Get current task in moving semanteme
+    pub fn take_current(&mut self) -> Option<Arc<TaskControlBlock>> {
+        self.current.take()
     }
-    ///Get current task in moving semanteme
-    pub fn take_current(&mut self) -> Option<Arc<TaskControlBlock>> {
-        self.current.take()
-    }
-    ///Get current task in cloning semanteme
-    pub fn current(&self) -> Option<Arc<TaskControlBlock>> {
-        self.current.as_ref().map(Arc::clone)
+    ///Get current task in cloning semanteme
+    pub fn current(&self) -> Option<Arc<TaskControlBlock>> {
+        self.current.as_ref().map(Arc::clone)
     }
 }
 
-lazy_static! {
-    pub static ref PROCESSOR: UPSafeCell<Processor> = unsafe { UPSafeCell::new(Processor::new()) };
+lazy_static! {
+    pub static ref PROCESSOR: UPSafeCell<Processor> = unsafe { UPSafeCell::new(Processor::new()) };
 }
-///The main part of process execution and scheduling
-///Loop `fetch_task` to get the process that needs to run, and switch the process through `__switch`
-pub fn run_tasks() {
-    loop {
-        let mut processor = PROCESSOR.exclusive_access();
-        if let Some(task) = fetch_task() {
-            let idle_task_cx_ptr = processor.get_idle_task_cx_ptr();
-            // access coming task TCB exclusively
-            let mut task_inner = task.inner_exclusive_access();
-            let next_task_cx_ptr = &task_inner.task_cx as *const TaskContext;
-            task_inner.task_status = TaskStatus::Running;
-            drop(task_inner);
-            // release coming task TCB manually
-            processor.current = Some(task);
-            // release processor manually
-            drop(processor);
-            unsafe {
-                __switch(idle_task_cx_ptr, next_task_cx_ptr);
+///The main part of process execution and scheduling
+///Loop `fetch_task` to get the process that needs to run, and switch the process through `__switch`
+pub fn run_tasks() {
+    loop {
+        let mut processor = PROCESSOR.exclusive_access();
+        if let Some(task) = fetch_task() {
+            let idle_task_cx_ptr = processor.get_idle_task_cx_ptr();
+            // access coming task TCB exclusively
+            let mut task_inner = task.inner_exclusive_access();
+            let next_task_cx_ptr = &task_inner.task_cx as *const TaskContext;
+            task_inner.task_status = TaskStatus::Running;
+            drop(task_inner);
+            // release coming task TCB manually
+            processor.current = Some(task);
+            // release processor manually
+            drop(processor);
+            unsafe {
+                __switch(idle_task_cx_ptr, next_task_cx_ptr);
             }
         }
     }
 }
-///Take the current task,leaving a None in its place
-pub fn take_current_task() -> Option<Arc<TaskControlBlock>> {
-    PROCESSOR.exclusive_access().take_current()
+///Take the current task,leaving a None in its place
+pub fn take_current_task() -> Option<Arc<TaskControlBlock>> {
+    PROCESSOR.exclusive_access().take_current()
 }
-///Get running task
-pub fn current_task() -> Option<Arc<TaskControlBlock>> {
-    PROCESSOR.exclusive_access().current()
+///Get running task
+pub fn current_task() -> Option<Arc<TaskControlBlock>> {
+    PROCESSOR.exclusive_access().current()
 }
-///Get token of the address space of current task
-pub fn current_user_token() -> usize {
-    let task = current_task().unwrap();
-    let token = task.inner_exclusive_access().get_user_token();
-    token
+///Get token of the address space of current task
+pub fn current_user_token() -> usize {
+    let task = current_task().unwrap();
+    let token = task.inner_exclusive_access().get_user_token();
+    token
 }
-///Get the mutable reference to trap context of current task
-pub fn current_trap_cx() -> &'static mut TrapContext {
-    current_task()
-        .unwrap()
-        .inner_exclusive_access()
-        .get_trap_cx()
+///Get the mutable reference to trap context of current task
+pub fn current_trap_cx() -> &'static mut TrapContext {
+    current_task()
+        .unwrap()
+        .inner_exclusive_access()
+        .get_trap_cx()
 }
-///Return to idle control flow for new scheduling
-pub fn schedule(switched_task_cx_ptr: *mut TaskContext) {
-    let mut processor = PROCESSOR.exclusive_access();
-    let idle_task_cx_ptr = processor.get_idle_task_cx_ptr();
-    drop(processor);
-    unsafe {
-        __switch(switched_task_cx_ptr, idle_task_cx_ptr);
+///Return to idle control flow for new scheduling
+pub fn schedule(switched_task_cx_ptr: *mut TaskContext) {
+    let mut processor = PROCESSOR.exclusive_access();
+    let idle_task_cx_ptr = processor.get_idle_task_cx_ptr();
+    drop(processor);
+    unsafe {
+        __switch(switched_task_cx_ptr, idle_task_cx_ptr);
     }
 }
-
    
-
    \ No newline at end of file + \ No newline at end of file diff --git a/ch5/src/os/task/switch.rs.html b/ch5/src/os/task/switch.rs.html index 191a95d6..a14b8a8e 100644 --- a/ch5/src/os/task/switch.rs.html +++ b/ch5/src/os/task/switch.rs.html @@ -1,20 +1,19 @@ -switch.rs - source
    1
-2
-3
-4
-5
-6
-7
-8
-9
-
    //!Wrap `switch.S` as a function
-use super::TaskContext;
-use core::arch::global_asm;
+switch.rs - source
    1
+2
+3
+4
+5
+6
+7
+8
+9
+
    //!Wrap `switch.S` as a function
+use super::TaskContext;
+use core::arch::global_asm;
 
 global_asm!(include_str!("switch.S"));
 
-extern "C" {
-    pub fn __switch(current_task_cx_ptr: *mut TaskContext, next_task_cx_ptr: *const TaskContext);
+extern "C" {
+    pub fn __switch(current_task_cx_ptr: *mut TaskContext, next_task_cx_ptr: *const TaskContext);
 }
-
    
-
    \ No newline at end of file + \ No newline at end of file diff --git a/ch5/src/os/task/task.rs.html b/ch5/src/os/task/task.rs.html index b5af4248..cc18b38a 100644 --- a/ch5/src/os/task/task.rs.html +++ b/ch5/src/os/task/task.rs.html @@ -1,344 +1,343 @@ -task.rs - source
    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
-
    //!Implementation of [`TaskControlBlock`]
-use super::TaskContext;
-use super::{pid_alloc, KernelStack, PidHandle};
-use crate::config::TRAP_CONTEXT;
-use crate::mm::{MemorySet, PhysPageNum, VirtAddr, KERNEL_SPACE};
-use crate::sync::UPSafeCell;
-use crate::trap::{trap_handler, TrapContext};
-use alloc::sync::{Arc, Weak};
-use alloc::vec::Vec;
-use core::cell::RefMut;
+task.rs - source
    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
+
    //!Implementation of [`TaskControlBlock`]
+use super::TaskContext;
+use super::{pid_alloc, KernelStack, PidHandle};
+use crate::config::TRAP_CONTEXT;
+use crate::mm::{MemorySet, PhysPageNum, VirtAddr, KERNEL_SPACE};
+use crate::sync::UPSafeCell;
+use crate::trap::{trap_handler, TrapContext};
+use alloc::sync::{Arc, Weak};
+use alloc::vec::Vec;
+use core::cell::RefMut;
 
-pub struct TaskControlBlock {
-    // immutable
-    pub pid: PidHandle,
-    pub kernel_stack: KernelStack,
-    // mutable
-    inner: UPSafeCell<TaskControlBlockInner>,
+pub struct TaskControlBlock {
+    // immutable
+    pub pid: PidHandle,
+    pub kernel_stack: KernelStack,
+    // mutable
+    inner: UPSafeCell<TaskControlBlockInner>,
 }
 
-pub struct TaskControlBlockInner {
-    pub trap_cx_ppn: PhysPageNum,
-    pub base_size: usize,
-    pub task_cx: TaskContext,
-    pub task_status: TaskStatus,
-    pub memory_set: MemorySet,
-    pub parent: Option<Weak<TaskControlBlock>>,
-    pub children: Vec<Arc<TaskControlBlock>>,
-    pub exit_code: i32,
+pub struct TaskControlBlockInner {
+    pub trap_cx_ppn: PhysPageNum,
+    pub base_size: usize,
+    pub task_cx: TaskContext,
+    pub task_status: TaskStatus,
+    pub memory_set: MemorySet,
+    pub parent: Option<Weak<TaskControlBlock>>,
+    pub children: Vec<Arc<TaskControlBlock>>,
+    pub exit_code: i32,
 }
 
-impl TaskControlBlockInner {
+impl TaskControlBlockInner {
     /*
     pub fn get_task_cx_ptr2(&self) -> *const usize {
         &self.task_cx_ptr as *const usize
     }
-    */
-    pub fn get_trap_cx(&self) -> &'static mut TrapContext {
-        self.trap_cx_ppn.get_mut()
+    */
+    pub fn get_trap_cx(&self) -> &'static mut TrapContext {
+        self.trap_cx_ppn.get_mut()
     }
-    pub fn get_user_token(&self) -> usize {
-        self.memory_set.token()
+    pub fn get_user_token(&self) -> usize {
+        self.memory_set.token()
     }
-    fn get_status(&self) -> TaskStatus {
-        self.task_status
+    fn get_status(&self) -> TaskStatus {
+        self.task_status
     }
-    pub fn is_zombie(&self) -> bool {
-        self.get_status() == TaskStatus::Zombie
+    pub fn is_zombie(&self) -> bool {
+        self.get_status() == TaskStatus::Zombie
     }
 }
 
-impl TaskControlBlock {
-    pub fn inner_exclusive_access(&self) -> RefMut<'_, TaskControlBlockInner> {
-        self.inner.exclusive_access()
+impl TaskControlBlock {
+    pub fn inner_exclusive_access(&self) -> RefMut<'_, TaskControlBlockInner> {
+        self.inner.exclusive_access()
     }
-    pub fn new(elf_data: &[u8]) -> Self {
-        // memory_set with elf program headers/trampoline/trap context/user stack
-        let (memory_set, user_sp, entry_point) = MemorySet::from_elf(elf_data);
-        let trap_cx_ppn = memory_set
-            .translate(VirtAddr::from(TRAP_CONTEXT).into())
-            .unwrap()
-            .ppn();
-        // alloc a pid and a kernel stack in kernel space
-        let pid_handle = pid_alloc();
-        let kernel_stack = KernelStack::new(&pid_handle);
-        let kernel_stack_top = kernel_stack.get_top();
-        // push a task context which goes to trap_return to the top of kernel stack
-        let task_control_block = Self {
-            pid: pid_handle,
-            kernel_stack,
-            inner: unsafe {
-                UPSafeCell::new(TaskControlBlockInner {
-                    trap_cx_ppn,
-                    base_size: user_sp,
-                    task_cx: TaskContext::goto_trap_return(kernel_stack_top),
-                    task_status: TaskStatus::Ready,
-                    memory_set,
-                    parent: None,
-                    children: Vec::new(),
-                    exit_code: 0,
+    pub fn new(elf_data: &[u8]) -> Self {
+        // memory_set with elf program headers/trampoline/trap context/user stack
+        let (memory_set, user_sp, entry_point) = MemorySet::from_elf(elf_data);
+        let trap_cx_ppn = memory_set
+            .translate(VirtAddr::from(TRAP_CONTEXT).into())
+            .unwrap()
+            .ppn();
+        // alloc a pid and a kernel stack in kernel space
+        let pid_handle = pid_alloc();
+        let kernel_stack = KernelStack::new(&pid_handle);
+        let kernel_stack_top = kernel_stack.get_top();
+        // push a task context which goes to trap_return to the top of kernel stack
+        let task_control_block = Self {
+            pid: pid_handle,
+            kernel_stack,
+            inner: unsafe {
+                UPSafeCell::new(TaskControlBlockInner {
+                    trap_cx_ppn,
+                    base_size: user_sp,
+                    task_cx: TaskContext::goto_trap_return(kernel_stack_top),
+                    task_status: TaskStatus::Ready,
+                    memory_set,
+                    parent: None,
+                    children: Vec::new(),
+                    exit_code: 0,
                 })
             },
         };
-        // prepare TrapContext in user space
-        let trap_cx = task_control_block.inner_exclusive_access().get_trap_cx();
-        *trap_cx = TrapContext::app_init_context(
-            entry_point,
-            user_sp,
-            KERNEL_SPACE.exclusive_access().token(),
-            kernel_stack_top,
-            trap_handler as usize,
+        // prepare TrapContext in user space
+        let trap_cx = task_control_block.inner_exclusive_access().get_trap_cx();
+        *trap_cx = TrapContext::app_init_context(
+            entry_point,
+            user_sp,
+            KERNEL_SPACE.exclusive_access().token(),
+            kernel_stack_top,
+            trap_handler as usize,
         );
-        task_control_block
+        task_control_block
     }
-    pub fn exec(&self, elf_data: &[u8]) {
-        // memory_set with elf program headers/trampoline/trap context/user stack
-        let (memory_set, user_sp, entry_point) = MemorySet::from_elf(elf_data);
-        let trap_cx_ppn = memory_set
-            .translate(VirtAddr::from(TRAP_CONTEXT).into())
-            .unwrap()
-            .ppn();
+    pub fn exec(&self, elf_data: &[u8]) {
+        // memory_set with elf program headers/trampoline/trap context/user stack
+        let (memory_set, user_sp, entry_point) = MemorySet::from_elf(elf_data);
+        let trap_cx_ppn = memory_set
+            .translate(VirtAddr::from(TRAP_CONTEXT).into())
+            .unwrap()
+            .ppn();
 
-        // **** access inner exclusively
-        let mut inner = self.inner_exclusive_access();
-        // substitute memory_set
-        inner.memory_set = memory_set;
-        // update trap_cx ppn
-        inner.trap_cx_ppn = trap_cx_ppn;
-        // initialize base_size
-        inner.base_size = user_sp;
-        // initialize trap_cx
-        let trap_cx = inner.get_trap_cx();
-        *trap_cx = TrapContext::app_init_context(
-            entry_point,
-            user_sp,
-            KERNEL_SPACE.exclusive_access().token(),
-            self.kernel_stack.get_top(),
-            trap_handler as usize,
+        // **** access inner exclusively
+        let mut inner = self.inner_exclusive_access();
+        // substitute memory_set
+        inner.memory_set = memory_set;
+        // update trap_cx ppn
+        inner.trap_cx_ppn = trap_cx_ppn;
+        // initialize base_size
+        inner.base_size = user_sp;
+        // initialize trap_cx
+        let trap_cx = inner.get_trap_cx();
+        *trap_cx = TrapContext::app_init_context(
+            entry_point,
+            user_sp,
+            KERNEL_SPACE.exclusive_access().token(),
+            self.kernel_stack.get_top(),
+            trap_handler as usize,
         );
-        // **** release inner automatically
-    }
-    pub fn fork(self: &Arc<Self>) -> Arc<Self> {
-        // ---- access parent PCB exclusively
-        let mut parent_inner = self.inner_exclusive_access();
-        // copy user space(include trap context)
-        let memory_set = MemorySet::from_existed_user(&parent_inner.memory_set);
-        let trap_cx_ppn = memory_set
-            .translate(VirtAddr::from(TRAP_CONTEXT).into())
-            .unwrap()
-            .ppn();
-        // alloc a pid and a kernel stack in kernel space
-        let pid_handle = pid_alloc();
-        let kernel_stack = KernelStack::new(&pid_handle);
-        let kernel_stack_top = kernel_stack.get_top();
-        let task_control_block = Arc::new(TaskControlBlock {
-            pid: pid_handle,
-            kernel_stack,
-            inner: unsafe {
-                UPSafeCell::new(TaskControlBlockInner {
-                    trap_cx_ppn,
-                    base_size: parent_inner.base_size,
-                    task_cx: TaskContext::goto_trap_return(kernel_stack_top),
-                    task_status: TaskStatus::Ready,
-                    memory_set,
-                    parent: Some(Arc::downgrade(self)),
-                    children: Vec::new(),
-                    exit_code: 0,
+        // **** release inner automatically
+    }
+    pub fn fork(self: &Arc<Self>) -> Arc<Self> {
+        // ---- access parent PCB exclusively
+        let mut parent_inner = self.inner_exclusive_access();
+        // copy user space(include trap context)
+        let memory_set = MemorySet::from_existed_user(&parent_inner.memory_set);
+        let trap_cx_ppn = memory_set
+            .translate(VirtAddr::from(TRAP_CONTEXT).into())
+            .unwrap()
+            .ppn();
+        // alloc a pid and a kernel stack in kernel space
+        let pid_handle = pid_alloc();
+        let kernel_stack = KernelStack::new(&pid_handle);
+        let kernel_stack_top = kernel_stack.get_top();
+        let task_control_block = Arc::new(TaskControlBlock {
+            pid: pid_handle,
+            kernel_stack,
+            inner: unsafe {
+                UPSafeCell::new(TaskControlBlockInner {
+                    trap_cx_ppn,
+                    base_size: parent_inner.base_size,
+                    task_cx: TaskContext::goto_trap_return(kernel_stack_top),
+                    task_status: TaskStatus::Ready,
+                    memory_set,
+                    parent: Some(Arc::downgrade(self)),
+                    children: Vec::new(),
+                    exit_code: 0,
                 })
             },
         });
-        // add child
-        parent_inner.children.push(task_control_block.clone());
-        // modify kernel_sp in trap_cx
-        // **** access children PCB exclusively
-        let trap_cx = task_control_block.inner_exclusive_access().get_trap_cx();
-        trap_cx.kernel_sp = kernel_stack_top;
-        // return
-        task_control_block
-        // ---- release parent PCB automatically
-        // **** release children PCB automatically
-    }
-    pub fn getpid(&self) -> usize {
-        self.pid.0
-    }
+        // add child
+        parent_inner.children.push(task_control_block.clone());
+        // modify kernel_sp in trap_cx
+        // **** access children PCB exclusively
+        let trap_cx = task_control_block.inner_exclusive_access().get_trap_cx();
+        trap_cx.kernel_sp = kernel_stack_top;
+        // return
+        task_control_block
+        // ---- release parent PCB automatically
+        // **** release children PCB automatically
+    }
+    pub fn getpid(&self) -> usize {
+        self.pid.0
+    }
 }
 
-#[derive(Copy, Clone, PartialEq)]
-pub enum TaskStatus {
-    Ready,
-    Running,
-    Zombie,
+#[derive(Copy, Clone, PartialEq)]
+pub enum TaskStatus {
+    Ready,
+    Running,
+    Zombie,
 }
-
    
-
    \ No newline at end of file + \ No newline at end of file diff --git a/ch5/src/os/timer.rs.html b/ch5/src/os/timer.rs.html index b6c263b1..d4830ce5 100644 --- a/ch5/src/os/timer.rs.html +++ b/ch5/src/os/timer.rs.html @@ -1,42 +1,41 @@ -timer.rs - source
    1
-2
-3
-4
-5
-6
-7
-8
-9
-10
-11
-12
-13
-14
-15
-16
-17
-18
-19
-20
-
    //! RISC-V timer-related functionality
+timer.rs - source
    1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+
    //! RISC-V timer-related functionality
 
-use crate::config::CLOCK_FREQ;
-use crate::sbi::set_timer;
-use riscv::register::time;
+use crate::config::CLOCK_FREQ;
+use crate::sbi::set_timer;
+use riscv::register::time;
 
-const TICKS_PER_SEC: usize = 100;
-const MSEC_PER_SEC: usize = 1000;
-///get current time
-pub fn get_time() -> usize {
-    time::read()
+const TICKS_PER_SEC: usize = 100;
+const MSEC_PER_SEC: usize = 1000;
+///get current time
+pub fn get_time() -> usize {
+    time::read()
 }
-/// get current time in microseconds
-pub fn get_time_ms() -> usize {
-    time::read() / (CLOCK_FREQ / MSEC_PER_SEC)
+/// get current time in microseconds
+pub fn get_time_ms() -> usize {
+    time::read() / (CLOCK_FREQ / MSEC_PER_SEC)
 }
-/// set the next timer interrupt
-pub fn set_next_trigger() {
-    set_timer(get_time() + CLOCK_FREQ / TICKS_PER_SEC);
+/// set the next timer interrupt
+pub fn set_next_trigger() {
+    set_timer(get_time() + CLOCK_FREQ / TICKS_PER_SEC);
 }
-
    
-
    \ No newline at end of file + \ No newline at end of file diff --git a/ch5/src/os/trap/context.rs.html b/ch5/src/os/trap/context.rs.html index 9e87e174..74b6252d 100644 --- a/ch5/src/os/trap/context.rs.html +++ b/ch5/src/os/trap/context.rs.html @@ -1,98 +1,97 @@ -context.rs - source
    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
-
    //! Implementation of [`TrapContext`]
-use riscv::register::sstatus::{self, Sstatus, SPP};
+context.rs - source
    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
+
    //! Implementation of [`TrapContext`]
+use riscv::register::sstatus::{self, Sstatus, SPP};
 
-#[repr(C)]
-///trap context structure containing sstatus, sepc and registers
-pub struct TrapContext {
-    /// general regs[0..31]
-    pub x: [usize; 32],
-    /// CSR sstatus      
-    pub sstatus: Sstatus,
-    /// CSR sepc
-    pub sepc: usize,
-    /// Addr of Page Table
-    pub kernel_satp: usize,
-    /// kernel stack
-    pub kernel_sp: usize,
-    /// Addr of trap_handler function
-    pub trap_handler: usize,
+#[repr(C)]
+///trap context structure containing sstatus, sepc and registers
+pub struct TrapContext {
+    /// general regs[0..31]
+    pub x: [usize; 32],
+    /// CSR sstatus      
+    pub sstatus: Sstatus,
+    /// CSR sepc
+    pub sepc: usize,
+    /// Addr of Page Table
+    pub kernel_satp: usize,
+    /// kernel stack
+    pub kernel_sp: usize,
+    /// Addr of trap_handler function
+    pub trap_handler: usize,
 }
 
-impl TrapContext {
-    ///set stack pointer to x_2 reg (sp)
-    pub fn set_sp(&mut self, sp: usize) {
-        self.x[2] = sp;
+impl TrapContext {
+    ///set stack pointer to x_2 reg (sp)
+    pub fn set_sp(&mut self, sp: usize) {
+        self.x[2] = sp;
     }
-    ///init app context
-    pub fn app_init_context(
-        entry: usize,
-        sp: usize,
-        kernel_satp: usize,
-        kernel_sp: usize,
-        trap_handler: usize,
-    ) -> Self {
-        let mut sstatus = sstatus::read();
-        // set CPU privilege to User after trapping back
-        sstatus.set_spp(SPP::User);
-        let mut cx = Self {
-            x: [0; 32],
-            sstatus,
-            sepc: entry,
-            kernel_satp,
-            kernel_sp,
-            trap_handler,
+    ///init app context
+    pub fn app_init_context(
+        entry: usize,
+        sp: usize,
+        kernel_satp: usize,
+        kernel_sp: usize,
+        trap_handler: usize,
+    ) -> Self {
+        let mut sstatus = sstatus::read();
+        // set CPU privilege to User after trapping back
+        sstatus.set_spp(SPP::User);
+        let mut cx = Self {
+            x: [0; 32],
+            sstatus,
+            sepc: entry,
+            kernel_satp,
+            kernel_sp,
+            trap_handler,
         };
-        cx.set_sp(sp);
-        cx
+        cx.set_sp(sp);
+        cx
     }
 }
-
    
-
    \ No newline at end of file + \ No newline at end of file diff --git a/ch5/src/os/trap/mod.rs.html b/ch5/src/os/trap/mod.rs.html index f93e2d8f..d970ec17 100644 --- a/ch5/src/os/trap/mod.rs.html +++ b/ch5/src/os/trap/mod.rs.html @@ -1,276 +1,275 @@ -mod.rs - source
    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
-
    //! Trap handling functionality
-//!
-//! For rCore, we have a single trap entry point, namely `__alltraps`. At
-//! initialization in [`init()`], we set the `stvec` CSR to point to it.
-//!
-//! All traps go through `__alltraps`, which is defined in `trap.S`. The
-//! assembly language code does just enough work restore the kernel space
-//! context, ensuring that Rust code safely runs, and transfers control to
-//! [`trap_handler()`].
-//!
-//! It then calls different functionality based on what exactly the exception
-//! was. For example, timer interrupts trigger task preemption, and syscalls go
-//! to [`syscall()`].
-mod context;
+mod.rs - source
    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
+
    //! Trap handling functionality
+//!
+//! For rCore, we have a single trap entry point, namely `__alltraps`. At
+//! initialization in [`init()`], we set the `stvec` CSR to point to it.
+//!
+//! All traps go through `__alltraps`, which is defined in `trap.S`. The
+//! assembly language code does just enough work restore the kernel space
+//! context, ensuring that Rust code safely runs, and transfers control to
+//! [`trap_handler()`].
+//!
+//! It then calls different functionality based on what exactly the exception
+//! was. For example, timer interrupts trigger task preemption, and syscalls go
+//! to [`syscall()`].
+mod context;
 
-use crate::config::{TRAMPOLINE, TRAP_CONTEXT};
-use crate::syscall::syscall;
-use crate::task::{
-    current_trap_cx, current_user_token, exit_current_and_run_next, suspend_current_and_run_next,
+use crate::config::{TRAMPOLINE, TRAP_CONTEXT};
+use crate::syscall::syscall;
+use crate::task::{
+    current_trap_cx, current_user_token, exit_current_and_run_next, suspend_current_and_run_next,
 };
-use crate::timer::set_next_trigger;
-use core::arch::{asm, global_asm};
-use riscv::register::{
-    mtvec::TrapMode,
-    scause::{self, Exception, Interrupt, Trap},
-    sie, stval, stvec,
+use crate::timer::set_next_trigger;
+use core::arch::{asm, global_asm};
+use riscv::register::{
+    mtvec::TrapMode,
+    scause::{self, Exception, Interrupt, Trap},
+    sie, stval, stvec,
 };
 
 global_asm!(include_str!("trap.S"));
-/// initialize CSR `stvec` as the entry of `__alltraps`
-pub fn init() {
-    set_kernel_trap_entry();
+/// initialize CSR `stvec` as the entry of `__alltraps`
+pub fn init() {
+    set_kernel_trap_entry();
 }
 
-fn set_kernel_trap_entry() {
-    unsafe {
-        stvec::write(trap_from_kernel as usize, TrapMode::Direct);
+fn set_kernel_trap_entry() {
+    unsafe {
+        stvec::write(trap_from_kernel as usize, TrapMode::Direct);
     }
 }
 
-fn set_user_trap_entry() {
-    unsafe {
-        stvec::write(TRAMPOLINE as usize, TrapMode::Direct);
+fn set_user_trap_entry() {
+    unsafe {
+        stvec::write(TRAMPOLINE as usize, TrapMode::Direct);
     }
 }
-/// enable timer interrupt in sie CSR
-pub fn enable_timer_interrupt() {
-    unsafe {
-        sie::set_stimer();
+/// enable timer interrupt in sie CSR
+pub fn enable_timer_interrupt() {
+    unsafe {
+        sie::set_stimer();
     }
 }
 
-#[no_mangle]
-/// handle an interrupt, exception, or system call from user space
-pub fn trap_handler() -> ! {
-    set_kernel_trap_entry();
-    let scause = scause::read();
-    let stval = stval::read();
-    match scause.cause() {
-        Trap::Exception(Exception::UserEnvCall) => {
-            // jump to next instruction anyway
-            let mut cx = current_trap_cx();
-            cx.sepc += 4;
-            // get system call return value
-            let result = syscall(cx.x[17], [cx.x[10], cx.x[11], cx.x[12]]);
-            // cx is changed during sys_exec, so we have to call it again
-            cx = current_trap_cx();
-            cx.x[10] = result as usize;
+#[no_mangle]
+/// handle an interrupt, exception, or system call from user space
+pub fn trap_handler() -> ! {
+    set_kernel_trap_entry();
+    let scause = scause::read();
+    let stval = stval::read();
+    match scause.cause() {
+        Trap::Exception(Exception::UserEnvCall) => {
+            // jump to next instruction anyway
+            let mut cx = current_trap_cx();
+            cx.sepc += 4;
+            // get system call return value
+            let result = syscall(cx.x[17], [cx.x[10], cx.x[11], cx.x[12]]);
+            // cx is changed during sys_exec, so we have to call it again
+            cx = current_trap_cx();
+            cx.x[10] = result as usize;
         }
-        Trap::Exception(Exception::StoreFault)
-        | Trap::Exception(Exception::StorePageFault)
-        | Trap::Exception(Exception::InstructionFault)
-        | Trap::Exception(Exception::InstructionPageFault)
-        | Trap::Exception(Exception::LoadFault)
-        | Trap::Exception(Exception::LoadPageFault) => {
+        Trap::Exception(Exception::StoreFault)
+        | Trap::Exception(Exception::StorePageFault)
+        | Trap::Exception(Exception::InstructionFault)
+        | Trap::Exception(Exception::InstructionPageFault)
+        | Trap::Exception(Exception::LoadFault)
+        | Trap::Exception(Exception::LoadPageFault) => {
             println!(
                 "[kernel] {:?} in application, bad addr = {:#x}, bad instruction = {:#x}, kernel killed it.",
-                scause.cause(),
-                stval,
-                current_trap_cx().sepc,
+                scause.cause(),
+                stval,
+                current_trap_cx().sepc,
             );
-            // page fault exit code
-            exit_current_and_run_next(-2);
+            // page fault exit code
+            exit_current_and_run_next(-2);
         }
-        Trap::Exception(Exception::IllegalInstruction) => {
+        Trap::Exception(Exception::IllegalInstruction) => {
             println!("[kernel] IllegalInstruction in application, kernel killed it.");
-            // illegal instruction exit code
-            exit_current_and_run_next(-3);
+            // illegal instruction exit code
+            exit_current_and_run_next(-3);
         }
-        Trap::Interrupt(Interrupt::SupervisorTimer) => {
-            set_next_trigger();
-            suspend_current_and_run_next();
+        Trap::Interrupt(Interrupt::SupervisorTimer) => {
+            set_next_trigger();
+            suspend_current_and_run_next();
         }
-        _ => {
+        _ => {
             panic!(
                 "Unsupported trap {:?}, stval = {:#x}!",
-                scause.cause(),
-                stval
+                scause.cause(),
+                stval
             );
         }
     }
-    trap_return();
+    trap_return();
 }
 
-#[no_mangle]
-/// set the new addr of __restore asm function in TRAMPOLINE page,
-/// set the reg a0 = trap_cx_ptr, reg a1 = phy addr of usr page table,
-/// finally, jump to new addr of __restore asm function
-pub fn trap_return() -> ! {
-    set_user_trap_entry();
-    let trap_cx_ptr = TRAP_CONTEXT;
-    let user_satp = current_user_token();
-    extern "C" {
-        fn __alltraps();
-        fn __restore();
+#[no_mangle]
+/// set the new addr of __restore asm function in TRAMPOLINE page,
+/// set the reg a0 = trap_cx_ptr, reg a1 = phy addr of usr page table,
+/// finally, jump to new addr of __restore asm function
+pub fn trap_return() -> ! {
+    set_user_trap_entry();
+    let trap_cx_ptr = TRAP_CONTEXT;
+    let user_satp = current_user_token();
+    extern "C" {
+        fn __alltraps();
+        fn __restore();
     }
-    let restore_va = __restore as usize - __alltraps as usize + TRAMPOLINE;
-    unsafe {
+    let restore_va = __restore as usize - __alltraps as usize + TRAMPOLINE;
+    unsafe {
         asm!(
             "fence.i",
             "jr {restore_va}",
-            restore_va = in(reg) restore_va,
-            in("a0") trap_cx_ptr,
-            in("a1") user_satp,
-            options(noreturn)
+            restore_va = in(reg) restore_va,
+            in("a0") trap_cx_ptr,
+            in("a1") user_satp,
+            options(noreturn)
         );
     }
 }
 
-#[no_mangle]
-/// Unimplement: traps/interrupts/exceptions from kernel mode
-/// Todo: Chapter 9: I/O device
-pub fn trap_from_kernel() -> ! {
-    panic!("a trap {:?} from kernel!", scause::read().cause());
+#[no_mangle]
+/// Unimplement: traps/interrupts/exceptions from kernel mode
+/// Todo: Chapter 9: I/O device
+pub fn trap_from_kernel() -> ! {
+    panic!("a trap {:?} from kernel!", scause::read().cause());
 }
 
-pub use context::TrapContext;
-
    
-
    \ No newline at end of file +pub use context::TrapContext; + \ No newline at end of file diff --git a/ch5/COPYRIGHT.txt b/ch5/static.files/COPYRIGHT-23e9bde6c69aea69.txt similarity index 97% rename from ch5/COPYRIGHT.txt rename to ch5/static.files/COPYRIGHT-23e9bde6c69aea69.txt index 34e48134..1447df79 100644 --- a/ch5/COPYRIGHT.txt +++ b/ch5/static.files/COPYRIGHT-23e9bde6c69aea69.txt @@ -1,3 +1,5 @@ +# REUSE-IgnoreStart + These documentation pages include resources by third parties. This copyright file applies only to those resources. The following third party resources are included, and carry their own copyright notices and license terms: @@ -44,3 +46,5 @@ included, and carry their own copyright notices and license terms: See SourceSerif4-LICENSE.md. This copyright file is intended to be distributed with rustdoc output. + +# REUSE-IgnoreEnd diff --git a/ch5/FiraSans-LICENSE.txt b/ch5/static.files/FiraSans-LICENSE-db4b642586e02d97.txt similarity index 99% rename from ch5/FiraSans-LICENSE.txt rename to ch5/static.files/FiraSans-LICENSE-db4b642586e02d97.txt index ff9afab0..d7e9c149 100644 --- a/ch5/FiraSans-LICENSE.txt +++ b/ch5/static.files/FiraSans-LICENSE-db4b642586e02d97.txt @@ -1,3 +1,5 @@ +// REUSE-IgnoreStart + Digitized data copyright (c) 2012-2015, The Mozilla Foundation and Telefonica S.A. with Reserved Font Name < Fira >, @@ -92,3 +94,5 @@ INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE. + +// REUSE-IgnoreEnd diff --git a/ch5/FiraSans-Medium.woff2 b/ch5/static.files/FiraSans-Medium-8f9a781e4970d388.woff2 similarity index 100% rename from ch5/FiraSans-Medium.woff2 rename to ch5/static.files/FiraSans-Medium-8f9a781e4970d388.woff2 diff --git a/ch5/FiraSans-Regular.woff2 b/ch5/static.files/FiraSans-Regular-018c141bf0843ffd.woff2 similarity index 100% rename from ch5/FiraSans-Regular.woff2 rename to ch5/static.files/FiraSans-Regular-018c141bf0843ffd.woff2 diff --git a/ch5/LICENSE-APACHE.txt b/ch5/static.files/LICENSE-APACHE-b91fa81cba47b86a.txt similarity index 100% rename from ch5/LICENSE-APACHE.txt rename to ch5/static.files/LICENSE-APACHE-b91fa81cba47b86a.txt diff --git a/ch5/LICENSE-MIT.txt b/ch5/static.files/LICENSE-MIT-65090b722b3f6c56.txt similarity index 100% rename from ch5/LICENSE-MIT.txt rename to ch5/static.files/LICENSE-MIT-65090b722b3f6c56.txt diff --git a/ch5/NanumBarunGothic.ttf.woff2 b/ch5/static.files/NanumBarunGothic-0f09457c7a19b7c6.ttf.woff2 similarity index 100% rename from ch5/NanumBarunGothic.ttf.woff2 rename to ch5/static.files/NanumBarunGothic-0f09457c7a19b7c6.ttf.woff2 diff --git a/ch5/NanumBarunGothic-LICENSE.txt b/ch5/static.files/NanumBarunGothic-LICENSE-18c5adf4b52b4041.txt similarity index 99% rename from ch5/NanumBarunGothic-LICENSE.txt rename to ch5/static.files/NanumBarunGothic-LICENSE-18c5adf4b52b4041.txt index 0bf46682..4b3edc29 100644 --- a/ch5/NanumBarunGothic-LICENSE.txt +++ b/ch5/static.files/NanumBarunGothic-LICENSE-18c5adf4b52b4041.txt @@ -1,3 +1,5 @@ +// REUSE-IgnoreStart + Copyright (c) 2010, NAVER Corporation (https://www.navercorp.com/), with Reserved Font Name Nanum, Naver Nanum, NanumGothic, Naver NanumGothic, @@ -97,3 +99,5 @@ INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE. + +// REUSE-IgnoreEnd diff --git a/ch5/SourceCodePro-It.ttf.woff2 b/ch5/static.files/SourceCodePro-It-1cc31594bf4f1f79.ttf.woff2 similarity index 100% rename from ch5/SourceCodePro-It.ttf.woff2 rename to ch5/static.files/SourceCodePro-It-1cc31594bf4f1f79.ttf.woff2 diff --git a/ch5/SourceCodePro-LICENSE.txt b/ch5/static.files/SourceCodePro-LICENSE-d180d465a756484a.txt similarity index 99% rename from ch5/SourceCodePro-LICENSE.txt rename to ch5/static.files/SourceCodePro-LICENSE-d180d465a756484a.txt index 07542572..0d2941e1 100644 --- a/ch5/SourceCodePro-LICENSE.txt +++ b/ch5/static.files/SourceCodePro-LICENSE-d180d465a756484a.txt @@ -1,3 +1,5 @@ +// REUSE-IgnoreStart + Copyright 2010, 2012 Adobe Systems Incorporated (http://www.adobe.com/), with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark of Adobe Systems Incorporated in the United States and/or other countries. This Font Software is licensed under the SIL Open Font License, Version 1.1. @@ -91,3 +93,5 @@ INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE. + +// REUSE-IgnoreEnd diff --git a/ch5/SourceCodePro-Regular.ttf.woff2 b/ch5/static.files/SourceCodePro-Regular-562dcc5011b6de7d.ttf.woff2 similarity index 100% rename from ch5/SourceCodePro-Regular.ttf.woff2 rename to ch5/static.files/SourceCodePro-Regular-562dcc5011b6de7d.ttf.woff2 diff --git a/ch5/SourceCodePro-Semibold.ttf.woff2 b/ch5/static.files/SourceCodePro-Semibold-d899c5a5c4aeb14a.ttf.woff2 similarity index 100% rename from ch5/SourceCodePro-Semibold.ttf.woff2 rename to ch5/static.files/SourceCodePro-Semibold-d899c5a5c4aeb14a.ttf.woff2 diff --git a/ch5/static.files/SourceSerif4-Bold-a2c9cd1067f8b328.ttf.woff2 b/ch5/static.files/SourceSerif4-Bold-a2c9cd1067f8b328.ttf.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..181a07f63bef8f18e42a5a57463e0e60cf8e8035 GIT binary patch literal 81540 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 literal 0 HcmV?d00001 diff --git a/ch5/static.files/SourceSerif4-It-acdfaf1a8af734b1.ttf.woff2 b/ch5/static.files/SourceSerif4-It-acdfaf1a8af734b1.ttf.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..2ae08a7bedfed08cdfea76039c1bb1fa1d6cdf67 GIT binary patch literal 59716 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 tC40Gi`Mi4m<9BpxR%m?w=so8}_Gqj!BM1dG + Copyright 2014-2021 Adobe (http://www.adobe.com/), with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark of Adobe in the United States and/or other countries. +Copyright 2014 - 2023 Adobe (http://www.adobe.com/), with Reserved Font Name ‘Source’. All Rights Reserved. Source is a trademark of Adobe in the United States and/or other countries. This Font Software is licensed under the SIL Open Font License, Version 1.1. @@ -91,3 +94,5 @@ INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE. + + diff --git a/ch5/static.files/SourceSerif4-Regular-46f98efaafac5295.ttf.woff2 b/ch5/static.files/SourceSerif4-Regular-46f98efaafac5295.ttf.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..0263fc304226d90e224e53053855ad138303b70b GIT binary patch literal 76260 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 G0RRB5qhxRZ literal 0 HcmV?d00001 diff --git a/ch5/clipboard.svg b/ch5/static.files/clipboard-7571035ce49a181d.svg similarity index 100% rename from ch5/clipboard.svg rename to ch5/static.files/clipboard-7571035ce49a181d.svg diff --git a/ch5/favicon-16x16.png b/ch5/static.files/favicon-16x16-8b506e7a72182f1c.png similarity index 100% rename from ch5/favicon-16x16.png rename to ch5/static.files/favicon-16x16-8b506e7a72182f1c.png diff --git a/ch5/favicon.svg b/ch5/static.files/favicon-2c020d218678b618.svg similarity index 100% rename from ch5/favicon.svg rename to ch5/static.files/favicon-2c020d218678b618.svg diff --git a/ch5/favicon-32x32.png b/ch5/static.files/favicon-32x32-422f7d1d52889060.png similarity index 100% rename from ch5/favicon-32x32.png rename to ch5/static.files/favicon-32x32-422f7d1d52889060.png diff --git a/ch5/static.files/main-c5bd66d33317d69f.js b/ch5/static.files/main-c5bd66d33317d69f.js new file mode 100644 index 00000000..43133d66 --- /dev/null +++ b/ch5/static.files/main-c5bd66d33317d69f.js @@ -0,0 +1,12 @@ +"use strict";window.RUSTDOC_TOOLTIP_HOVER_MS=300;window.RUSTDOC_TOOLTIP_HOVER_EXIT_MS=450;function resourcePath(basename,extension){return getVar("root-path")+basename+getVar("resource-suffix")+extension}function hideMain(){addClass(document.getElementById(MAIN_ID),"hidden")}function showMain(){removeClass(document.getElementById(MAIN_ID),"hidden")}function elemIsInParent(elem,parent){while(elem&&elem!==document.body){if(elem===parent){return true}elem=elem.parentElement}return false}function blurHandler(event,parentElem,hideCallback){if(!elemIsInParent(document.activeElement,parentElem)&&!elemIsInParent(event.relatedTarget,parentElem)){hideCallback()}}window.rootPath=getVar("root-path");window.currentCrate=getVar("current-crate");function setMobileTopbar(){const mobileTopbar=document.querySelector(".mobile-topbar");const locationTitle=document.querySelector(".sidebar h2.location");if(mobileTopbar&&locationTitle){const mobileTitle=document.createElement("h2");mobileTitle.innerHTML=locationTitle.innerHTML;mobileTopbar.appendChild(mobileTitle)}}function getVirtualKey(ev){if("key"in ev&&typeof ev.key!=="undefined"){return ev.key}const c=ev.charCode||ev.keyCode;if(c===27){return"Escape"}return String.fromCharCode(c)}const MAIN_ID="main-content";const SETTINGS_BUTTON_ID="settings-menu";const ALTERNATIVE_DISPLAY_ID="alternative-display";const NOT_DISPLAYED_ID="not-displayed";const HELP_BUTTON_ID="help-button";function getSettingsButton(){return document.getElementById(SETTINGS_BUTTON_ID)}function getHelpButton(){return document.getElementById(HELP_BUTTON_ID)}function getNakedUrl(){return window.location.href.split("?")[0].split("#")[0]}function insertAfter(newNode,referenceNode){referenceNode.parentNode.insertBefore(newNode,referenceNode.nextSibling)}function getOrCreateSection(id,classes){let el=document.getElementById(id);if(!el){el=document.createElement("section");el.id=id;el.className=classes;insertAfter(el,document.getElementById(MAIN_ID))}return el}function getAlternativeDisplayElem(){return getOrCreateSection(ALTERNATIVE_DISPLAY_ID,"content hidden")}function getNotDisplayedElem(){return getOrCreateSection(NOT_DISPLAYED_ID,"hidden")}function switchDisplayedElement(elemToDisplay){const el=getAlternativeDisplayElem();if(el.children.length>0){getNotDisplayedElem().appendChild(el.firstElementChild)}if(elemToDisplay===null){addClass(el,"hidden");showMain();return}el.appendChild(elemToDisplay);hideMain();removeClass(el,"hidden")}function browserSupportsHistoryApi(){return window.history&&typeof window.history.pushState==="function"}function preLoadCss(cssUrl){const link=document.createElement("link");link.href=cssUrl;link.rel="preload";link.as="style";document.getElementsByTagName("head")[0].appendChild(link)}(function(){const isHelpPage=window.location.pathname.endsWith("/help.html");function loadScript(url){const script=document.createElement("script");script.src=url;document.head.append(script)}getSettingsButton().onclick=event=>{if(event.ctrlKey||event.altKey||event.metaKey){return}window.hideAllModals(false);addClass(getSettingsButton(),"rotate");event.preventDefault();loadScript(getVar("static-root-path")+getVar("settings-js"));setTimeout(()=>{const themes=getVar("themes").split(",");for(const theme of themes){if(theme!==""){preLoadCss(getVar("root-path")+theme+".css")}}},0)};window.searchState={loadingText:"Loading search results...",input:document.getElementsByClassName("search-input")[0],outputElement:()=>{let el=document.getElementById("search");if(!el){el=document.createElement("section");el.id="search";getNotDisplayedElem().appendChild(el)}return el},title:document.title,titleBeforeSearch:document.title,timeout:null,currentTab:0,focusedByTab:[null,null,null],clearInputTimeout:()=>{if(searchState.timeout!==null){clearTimeout(searchState.timeout);searchState.timeout=null}},isDisplayed:()=>searchState.outputElement().parentElement.id===ALTERNATIVE_DISPLAY_ID,focus:()=>{searchState.input.focus()},defocus:()=>{searchState.input.blur()},showResults:search=>{if(search===null||typeof search==="undefined"){search=searchState.outputElement()}switchDisplayedElement(search);searchState.mouseMovedAfterSearch=false;document.title=searchState.title},removeQueryParameters:()=>{document.title=searchState.titleBeforeSearch;if(browserSupportsHistoryApi()){history.replaceState(null,"",getNakedUrl()+window.location.hash)}},hideResults:()=>{switchDisplayedElement(null);searchState.removeQueryParameters()},getQueryStringParams:()=>{const params={};window.location.search.substring(1).split("&").map(s=>{const pair=s.split("=");params[decodeURIComponent(pair[0])]=typeof pair[1]==="undefined"?null:decodeURIComponent(pair[1])});return params},setup:()=>{const search_input=searchState.input;if(!searchState.input){return}let searchLoaded=false;function loadSearch(){if(!searchLoaded){searchLoaded=true;loadScript(getVar("static-root-path")+getVar("search-js"));loadScript(resourcePath("search-index",".js"))}}search_input.addEventListener("focus",()=>{search_input.origPlaceholder=search_input.placeholder;search_input.placeholder="Type your search here.";loadSearch()});if(search_input.value!==""){loadSearch()}const params=searchState.getQueryStringParams();if(params.search!==undefined){searchState.setLoadingSearch();loadSearch()}},setLoadingSearch:()=>{const search=searchState.outputElement();search.innerHTML="

    "+searchState.loadingText+"

    ";searchState.showResults(search)},};const toggleAllDocsId="toggle-all-docs";let savedHash="";function handleHashes(ev){if(ev!==null&&searchState.isDisplayed()&&ev.newURL){switchDisplayedElement(null);const hash=ev.newURL.slice(ev.newURL.indexOf("#")+1);if(browserSupportsHistoryApi()){history.replaceState(null,"",getNakedUrl()+window.location.search+"#"+hash)}const elem=document.getElementById(hash);if(elem){elem.scrollIntoView()}}const pageId=window.location.hash.replace(/^#/,"");if(savedHash!==pageId){savedHash=pageId;if(pageId!==""){expandSection(pageId)}}}function onHashChange(ev){hideSidebar();handleHashes(ev)}function openParentDetails(elem){while(elem){if(elem.tagName==="DETAILS"){elem.open=true}elem=elem.parentNode}}function expandSection(id){openParentDetails(document.getElementById(id))}function handleEscape(ev){searchState.clearInputTimeout();searchState.hideResults();ev.preventDefault();searchState.defocus();window.hideAllModals(true)}function handleShortcut(ev){const disableShortcuts=getSettingValue("disable-shortcuts")==="true";if(ev.ctrlKey||ev.altKey||ev.metaKey||disableShortcuts){return}if(document.activeElement.tagName==="INPUT"&&document.activeElement.type!=="checkbox"&&document.activeElement.type!=="radio"){switch(getVirtualKey(ev)){case"Escape":handleEscape(ev);break}}else{switch(getVirtualKey(ev)){case"Escape":handleEscape(ev);break;case"s":case"S":ev.preventDefault();searchState.focus();break;case"+":ev.preventDefault();expandAllDocs();break;case"-":ev.preventDefault();collapseAllDocs();break;case"?":showHelp();break;default:break}}}document.addEventListener("keypress",handleShortcut);document.addEventListener("keydown",handleShortcut);function addSidebarItems(){if(!window.SIDEBAR_ITEMS){return}const sidebar=document.getElementsByClassName("sidebar-elems")[0];function block(shortty,id,longty){const filtered=window.SIDEBAR_ITEMS[shortty];if(!filtered){return}const h3=document.createElement("h3");h3.innerHTML=`${longty}`;const ul=document.createElement("ul");ul.className="block "+shortty;for(const name of filtered){let path;if(shortty==="mod"){path=name+"/index.html"}else{path=shortty+"."+name+".html"}const current_page=document.location.href.split("/").pop();const link=document.createElement("a");link.href=path;if(path===current_page){link.className="current"}link.textContent=name;const li=document.createElement("li");li.appendChild(link);ul.appendChild(li)}sidebar.appendChild(h3);sidebar.appendChild(ul)}if(sidebar){block("primitive","primitives","Primitive Types");block("mod","modules","Modules");block("macro","macros","Macros");block("struct","structs","Structs");block("enum","enums","Enums");block("union","unions","Unions");block("constant","constants","Constants");block("static","static","Statics");block("trait","traits","Traits");block("fn","functions","Functions");block("type","types","Type Aliases");block("foreigntype","foreign-types","Foreign Types");block("keyword","keywords","Keywords");block("traitalias","trait-aliases","Trait Aliases")}}window.register_implementors=imp=>{const implementors=document.getElementById("implementors-list");const synthetic_implementors=document.getElementById("synthetic-implementors-list");const inlined_types=new Set();const TEXT_IDX=0;const SYNTHETIC_IDX=1;const TYPES_IDX=2;if(synthetic_implementors){onEachLazy(synthetic_implementors.getElementsByClassName("impl"),el=>{const aliases=el.getAttribute("data-aliases");if(!aliases){return}aliases.split(",").forEach(alias=>{inlined_types.add(alias)})})}let currentNbImpls=implementors.getElementsByClassName("impl").length;const traitName=document.querySelector(".main-heading h1 > .trait").textContent;const baseIdName="impl-"+traitName+"-";const libs=Object.getOwnPropertyNames(imp);const script=document.querySelector("script[data-ignore-extern-crates]");const ignoreExternCrates=new Set((script?script.getAttribute("data-ignore-extern-crates"):"").split(","));for(const lib of libs){if(lib===window.currentCrate||ignoreExternCrates.has(lib)){continue}const structs=imp[lib];struct_loop:for(const struct of structs){const list=struct[SYNTHETIC_IDX]?synthetic_implementors:implementors;if(struct[SYNTHETIC_IDX]){for(const struct_type of struct[TYPES_IDX]){if(inlined_types.has(struct_type)){continue struct_loop}inlined_types.add(struct_type)}}const code=document.createElement("h3");code.innerHTML=struct[TEXT_IDX];addClass(code,"code-header");onEachLazy(code.getElementsByTagName("a"),elem=>{const href=elem.getAttribute("href");if(href&&!/^(?:[a-z+]+:)?\/\//.test(href)){elem.setAttribute("href",window.rootPath+href)}});const currentId=baseIdName+currentNbImpls;const anchor=document.createElement("a");anchor.href="#"+currentId;addClass(anchor,"anchor");const display=document.createElement("div");display.id=currentId;addClass(display,"impl");display.appendChild(anchor);display.appendChild(code);list.appendChild(display);currentNbImpls+=1}}};if(window.pending_implementors){window.register_implementors(window.pending_implementors)}function addSidebarCrates(){if(!window.ALL_CRATES){return}const sidebarElems=document.getElementsByClassName("sidebar-elems")[0];if(!sidebarElems){return}const h3=document.createElement("h3");h3.innerHTML="Crates";const ul=document.createElement("ul");ul.className="block crate";for(const crate of window.ALL_CRATES){const link=document.createElement("a");link.href=window.rootPath+crate+"/index.html";if(window.rootPath!=="./"&&crate===window.currentCrate){link.className="current"}link.textContent=crate;const li=document.createElement("li");li.appendChild(link);ul.appendChild(li)}sidebarElems.appendChild(h3);sidebarElems.appendChild(ul)}function expandAllDocs(){const innerToggle=document.getElementById(toggleAllDocsId);removeClass(innerToggle,"will-expand");onEachLazy(document.getElementsByClassName("toggle"),e=>{if(!hasClass(e,"type-contents-toggle")&&!hasClass(e,"more-examples-toggle")){e.open=true}});innerToggle.title="collapse all docs";innerToggle.children[0].innerText="\u2212"}function collapseAllDocs(){const innerToggle=document.getElementById(toggleAllDocsId);addClass(innerToggle,"will-expand");onEachLazy(document.getElementsByClassName("toggle"),e=>{if(e.parentNode.id!=="implementations-list"||(!hasClass(e,"implementors-toggle")&&!hasClass(e,"type-contents-toggle"))){e.open=false}});innerToggle.title="expand all docs";innerToggle.children[0].innerText="+"}function toggleAllDocs(){const innerToggle=document.getElementById(toggleAllDocsId);if(!innerToggle){return}if(hasClass(innerToggle,"will-expand")){expandAllDocs()}else{collapseAllDocs()}}(function(){const toggles=document.getElementById(toggleAllDocsId);if(toggles){toggles.onclick=toggleAllDocs}const hideMethodDocs=getSettingValue("auto-hide-method-docs")==="true";const hideImplementations=getSettingValue("auto-hide-trait-implementations")==="true";const hideLargeItemContents=getSettingValue("auto-hide-large-items")!=="false";function setImplementorsTogglesOpen(id,open){const list=document.getElementById(id);if(list!==null){onEachLazy(list.getElementsByClassName("implementors-toggle"),e=>{e.open=open})}}if(hideImplementations){setImplementorsTogglesOpen("trait-implementations-list",false);setImplementorsTogglesOpen("blanket-implementations-list",false)}onEachLazy(document.getElementsByClassName("toggle"),e=>{if(!hideLargeItemContents&&hasClass(e,"type-contents-toggle")){e.open=true}if(hideMethodDocs&&hasClass(e,"method-toggle")){e.open=false}})}());window.rustdoc_add_line_numbers_to_examples=()=>{onEachLazy(document.getElementsByClassName("rust-example-rendered"),x=>{const parent=x.parentNode;const line_numbers=parent.querySelectorAll(".example-line-numbers");if(line_numbers.length>0){return}const count=x.textContent.split("\n").length;const elems=[];for(let i=0;i{onEachLazy(document.getElementsByClassName("rust-example-rendered"),x=>{const parent=x.parentNode;const line_numbers=parent.querySelectorAll(".example-line-numbers");for(const node of line_numbers){parent.removeChild(node)}})};if(getSettingValue("line-numbers")==="true"){window.rustdoc_add_line_numbers_to_examples()}function showSidebar(){window.hideAllModals(false);const sidebar=document.getElementsByClassName("sidebar")[0];addClass(sidebar,"shown")}function hideSidebar(){const sidebar=document.getElementsByClassName("sidebar")[0];removeClass(sidebar,"shown")}window.addEventListener("resize",()=>{if(window.CURRENT_TOOLTIP_ELEMENT){const base=window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE;const force_visible=base.TOOLTIP_FORCE_VISIBLE;hideTooltip(false);if(force_visible){showTooltip(base);base.TOOLTIP_FORCE_VISIBLE=true}}});const mainElem=document.getElementById(MAIN_ID);if(mainElem){mainElem.addEventListener("click",hideSidebar)}onEachLazy(document.querySelectorAll("a[href^='#']"),el=>{el.addEventListener("click",()=>{expandSection(el.hash.slice(1));hideSidebar()})});onEachLazy(document.querySelectorAll(".toggle > summary:not(.hideme)"),el=>{el.addEventListener("click",e=>{if(e.target.tagName!=="SUMMARY"&&e.target.tagName!=="A"){e.preventDefault()}})});function showTooltip(e){const notable_ty=e.getAttribute("data-notable-ty");if(!window.NOTABLE_TRAITS&¬able_ty){const data=document.getElementById("notable-traits-data");if(data){window.NOTABLE_TRAITS=JSON.parse(data.innerText)}else{throw new Error("showTooltip() called with notable without any notable traits!")}}if(window.CURRENT_TOOLTIP_ELEMENT&&window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE===e){clearTooltipHoverTimeout(window.CURRENT_TOOLTIP_ELEMENT);return}window.hideAllModals(false);const wrapper=document.createElement("div");if(notable_ty){wrapper.innerHTML="
    "+window.NOTABLE_TRAITS[notable_ty]+"
    "}else{if(e.getAttribute("title")!==null){e.setAttribute("data-title",e.getAttribute("title"));e.removeAttribute("title")}if(e.getAttribute("data-title")!==null){const titleContent=document.createElement("div");titleContent.className="content";titleContent.appendChild(document.createTextNode(e.getAttribute("data-title")));wrapper.appendChild(titleContent)}}wrapper.className="tooltip popover";const focusCatcher=document.createElement("div");focusCatcher.setAttribute("tabindex","0");focusCatcher.onfocus=hideTooltip;wrapper.appendChild(focusCatcher);const pos=e.getBoundingClientRect();wrapper.style.top=(pos.top+window.scrollY+pos.height)+"px";wrapper.style.left=0;wrapper.style.right="auto";wrapper.style.visibility="hidden";const body=document.getElementsByTagName("body")[0];body.appendChild(wrapper);const wrapperPos=wrapper.getBoundingClientRect();const finalPos=pos.left+window.scrollX-wrapperPos.width+24;if(finalPos>0){wrapper.style.left=finalPos+"px"}else{wrapper.style.setProperty("--popover-arrow-offset",(wrapperPos.right-pos.right+4)+"px")}wrapper.style.visibility="";window.CURRENT_TOOLTIP_ELEMENT=wrapper;window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE=e;clearTooltipHoverTimeout(window.CURRENT_TOOLTIP_ELEMENT);wrapper.onpointerenter=ev=>{if(ev.pointerType!=="mouse"){return}clearTooltipHoverTimeout(e)};wrapper.onpointerleave=ev=>{if(ev.pointerType!=="mouse"){return}if(!e.TOOLTIP_FORCE_VISIBLE&&!elemIsInParent(ev.relatedTarget,e)){setTooltipHoverTimeout(e,false);addClass(wrapper,"fade-out")}}}function setTooltipHoverTimeout(element,show){clearTooltipHoverTimeout(element);if(!show&&!window.CURRENT_TOOLTIP_ELEMENT){return}if(show&&window.CURRENT_TOOLTIP_ELEMENT){return}if(window.CURRENT_TOOLTIP_ELEMENT&&window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE!==element){return}element.TOOLTIP_HOVER_TIMEOUT=setTimeout(()=>{if(show){showTooltip(element)}else if(!element.TOOLTIP_FORCE_VISIBLE){hideTooltip(false)}},show?window.RUSTDOC_TOOLTIP_HOVER_MS:window.RUSTDOC_TOOLTIP_HOVER_EXIT_MS)}function clearTooltipHoverTimeout(element){if(element.TOOLTIP_HOVER_TIMEOUT!==undefined){removeClass(window.CURRENT_TOOLTIP_ELEMENT,"fade-out");clearTimeout(element.TOOLTIP_HOVER_TIMEOUT);delete element.TOOLTIP_HOVER_TIMEOUT}}function tooltipBlurHandler(event){if(window.CURRENT_TOOLTIP_ELEMENT&&!elemIsInParent(document.activeElement,window.CURRENT_TOOLTIP_ELEMENT)&&!elemIsInParent(event.relatedTarget,window.CURRENT_TOOLTIP_ELEMENT)&&!elemIsInParent(document.activeElement,window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE)&&!elemIsInParent(event.relatedTarget,window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE)){setTimeout(()=>hideTooltip(false),0)}}function hideTooltip(focus){if(window.CURRENT_TOOLTIP_ELEMENT){if(window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE.TOOLTIP_FORCE_VISIBLE){if(focus){window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE.focus()}window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE.TOOLTIP_FORCE_VISIBLE=false}const body=document.getElementsByTagName("body")[0];body.removeChild(window.CURRENT_TOOLTIP_ELEMENT);clearTooltipHoverTimeout(window.CURRENT_TOOLTIP_ELEMENT);window.CURRENT_TOOLTIP_ELEMENT=null}}onEachLazy(document.getElementsByClassName("tooltip"),e=>{e.onclick=()=>{e.TOOLTIP_FORCE_VISIBLE=e.TOOLTIP_FORCE_VISIBLE?false:true;if(window.CURRENT_TOOLTIP_ELEMENT&&!e.TOOLTIP_FORCE_VISIBLE){hideTooltip(true)}else{showTooltip(e);window.CURRENT_TOOLTIP_ELEMENT.setAttribute("tabindex","0");window.CURRENT_TOOLTIP_ELEMENT.focus();window.CURRENT_TOOLTIP_ELEMENT.onblur=tooltipBlurHandler}return false};e.onpointerenter=ev=>{if(ev.pointerType!=="mouse"){return}setTooltipHoverTimeout(e,true)};e.onpointermove=ev=>{if(ev.pointerType!=="mouse"){return}setTooltipHoverTimeout(e,true)};e.onpointerleave=ev=>{if(ev.pointerType!=="mouse"){return}if(!e.TOOLTIP_FORCE_VISIBLE&&!elemIsInParent(ev.relatedTarget,window.CURRENT_TOOLTIP_ELEMENT)){setTooltipHoverTimeout(e,false);addClass(window.CURRENT_TOOLTIP_ELEMENT,"fade-out")}}});const sidebar_menu_toggle=document.getElementsByClassName("sidebar-menu-toggle")[0];if(sidebar_menu_toggle){sidebar_menu_toggle.addEventListener("click",()=>{const sidebar=document.getElementsByClassName("sidebar")[0];if(!hasClass(sidebar,"shown")){showSidebar()}else{hideSidebar()}})}function helpBlurHandler(event){blurHandler(event,getHelpButton(),window.hidePopoverMenus)}function buildHelpMenu(){const book_info=document.createElement("span");const channel=getVar("channel");book_info.className="top";book_info.innerHTML=`You can find more information in \ +the rustdoc book.`;const shortcuts=[["?","Show this help dialog"],["S","Focus the search field"],["↑","Move up in search results"],["↓","Move down in search results"],["← / →","Switch result tab (when results focused)"],["⏎","Go to active search result"],["+","Expand all sections"],["-","Collapse all sections"],].map(x=>"
    "+x[0].split(" ").map((y,index)=>((index&1)===0?""+y+"":" "+y+" ")).join("")+"
    "+x[1]+"
    ").join("");const div_shortcuts=document.createElement("div");addClass(div_shortcuts,"shortcuts");div_shortcuts.innerHTML="

    Keyboard Shortcuts

    "+shortcuts+"
    ";const infos=[`For a full list of all search features, take a look here.`,"Prefix searches with a type followed by a colon (e.g., fn:) to \ + restrict the search to a given item kind.","Accepted kinds are: fn, mod, struct, \ + enum, trait, type, macro, \ + and const.","Search functions by type signature (e.g., vec -> usize or \ + -> vec or String, enum:Cow -> bool)","You can look for items with an exact name by putting double quotes around \ + your request: \"string\"","Look for functions that accept or return \ + slices and \ + arrays by writing \ + square brackets (e.g., -> [u8] or [] -> Option)","Look for items inside another one by searching for a path: vec::Vec",].map(x=>"

    "+x+"

    ").join("");const div_infos=document.createElement("div");addClass(div_infos,"infos");div_infos.innerHTML="

    Search Tricks

    "+infos;const rustdoc_version=document.createElement("span");rustdoc_version.className="bottom";const rustdoc_version_code=document.createElement("code");rustdoc_version_code.innerText="rustdoc "+getVar("rustdoc-version");rustdoc_version.appendChild(rustdoc_version_code);const container=document.createElement("div");if(!isHelpPage){container.className="popover"}container.id="help";container.style.display="none";const side_by_side=document.createElement("div");side_by_side.className="side-by-side";side_by_side.appendChild(div_shortcuts);side_by_side.appendChild(div_infos);container.appendChild(book_info);container.appendChild(side_by_side);container.appendChild(rustdoc_version);if(isHelpPage){const help_section=document.createElement("section");help_section.appendChild(container);document.getElementById("main-content").appendChild(help_section);container.style.display="block"}else{const help_button=getHelpButton();help_button.appendChild(container);container.onblur=helpBlurHandler;help_button.onblur=helpBlurHandler;help_button.children[0].onblur=helpBlurHandler}return container}window.hideAllModals=switchFocus=>{hideSidebar();window.hidePopoverMenus();hideTooltip(switchFocus)};window.hidePopoverMenus=()=>{onEachLazy(document.querySelectorAll(".search-form .popover"),elem=>{elem.style.display="none"})};function getHelpMenu(buildNeeded){let menu=getHelpButton().querySelector(".popover");if(!menu&&buildNeeded){menu=buildHelpMenu()}return menu}function showHelp(){getHelpButton().querySelector("a").focus();const menu=getHelpMenu(true);if(menu.style.display==="none"){window.hideAllModals();menu.style.display=""}}if(isHelpPage){showHelp();document.querySelector(`#${HELP_BUTTON_ID} > a`).addEventListener("click",event=>{const target=event.target;if(target.tagName!=="A"||target.parentElement.id!==HELP_BUTTON_ID||event.ctrlKey||event.altKey||event.metaKey){return}event.preventDefault()})}else{document.querySelector(`#${HELP_BUTTON_ID} > a`).addEventListener("click",event=>{const target=event.target;if(target.tagName!=="A"||target.parentElement.id!==HELP_BUTTON_ID||event.ctrlKey||event.altKey||event.metaKey){return}event.preventDefault();const menu=getHelpMenu(true);const shouldShowHelp=menu.style.display==="none";if(shouldShowHelp){showHelp()}else{window.hidePopoverMenus()}})}setMobileTopbar();addSidebarItems();addSidebarCrates();onHashChange(null);window.addEventListener("hashchange",onHashChange);searchState.setup()}());(function(){let reset_button_timeout=null;const but=document.getElementById("copy-path");if(!but){return}but.onclick=()=>{const parent=but.parentElement;const path=[];onEach(parent.childNodes,child=>{if(child.tagName==="A"){path.push(child.textContent)}});const el=document.createElement("textarea");el.value=path.join("::");el.setAttribute("readonly","");el.style.position="absolute";el.style.left="-9999px";document.body.appendChild(el);el.select();document.execCommand("copy");document.body.removeChild(el);but.children[0].style.display="none";let tmp;if(but.childNodes.length<2){tmp=document.createTextNode("✓");but.appendChild(tmp)}else{onEachLazy(but.childNodes,e=>{if(e.nodeType===Node.TEXT_NODE){tmp=e;return true}});tmp.textContent="✓"}if(reset_button_timeout!==null){window.clearTimeout(reset_button_timeout)}function reset_button(){tmp.textContent="";reset_button_timeout=null;but.children[0].style.display=""}reset_button_timeout=window.setTimeout(reset_button,1000)}}()) \ No newline at end of file diff --git a/ch5/normalize.css b/ch5/static.files/normalize-76eba96aa4d2e634.css similarity index 100% rename from ch5/normalize.css rename to ch5/static.files/normalize-76eba96aa4d2e634.css diff --git a/ch5/static.files/noscript-5d8b3c7633ad77ba.css b/ch5/static.files/noscript-5d8b3c7633ad77ba.css new file mode 100644 index 00000000..8c63ef06 --- /dev/null +++ b/ch5/static.files/noscript-5d8b3c7633ad77ba.css @@ -0,0 +1 @@ + #main-content .attributes{margin-left:0 !important;}#copy-path{display:none;}nav.sub{display:none;}.src .sidebar{display:none;}.notable-traits{display:none;}:root{--main-background-color:white;--main-color:black;--settings-input-color:#2196f3;--settings-input-border-color:#717171;--settings-button-color:#000;--settings-button-border-focus:#717171;--sidebar-background-color:#f5f5f5;--sidebar-background-color-hover:#e0e0e0;--code-block-background-color:#f5f5f5;--scrollbar-track-background-color:#dcdcdc;--scrollbar-thumb-background-color:rgba(36,37,39,0.6);--scrollbar-color:rgba(36,37,39,0.6) #d9d9d9;--headings-border-bottom-color:#ddd;--border-color:#e0e0e0;--button-background-color:#fff;--right-side-color:grey;--code-attribute-color:#999;--toggles-color:#999;--toggle-filter:none;--search-input-focused-border-color:#66afe9;--copy-path-button-color:#999;--copy-path-img-filter:invert(50%);--copy-path-img-hover-filter:invert(35%);--codeblock-error-hover-color:rgb(255,0,0);--codeblock-error-color:rgba(255,0,0,.5);--codeblock-ignore-hover-color:rgb(255,142,0);--codeblock-ignore-color:rgba(255,142,0,.6);--warning-border-color:#ff8e00;--type-link-color:#ad378a;--trait-link-color:#6e4fc9;--assoc-item-link-color:#3873ad;--function-link-color:#ad7c37;--macro-link-color:#068000;--keyword-link-color:#3873ad;--mod-link-color:#3873ad;--link-color:#3873ad;--sidebar-link-color:#356da4;--sidebar-current-link-background-color:#fff;--search-result-link-focus-background-color:#ccc;--search-result-border-color:#aaa3;--search-color:#000;--search-error-code-background-color:#d0cccc;--search-results-alias-color:#000;--search-results-grey-color:#999;--search-tab-title-count-color:#888;--search-tab-button-not-selected-border-top-color:#e6e6e6;--search-tab-button-not-selected-background:#e6e6e6;--search-tab-button-selected-border-top-color:#0089ff;--search-tab-button-selected-background:#fff;--stab-background-color:#fff5d6;--stab-code-color:#000;--code-highlight-kw-color:#8959a8;--code-highlight-kw-2-color:#4271ae;--code-highlight-lifetime-color:#b76514;--code-highlight-prelude-color:#4271ae;--code-highlight-prelude-val-color:#c82829;--code-highlight-number-color:#718c00;--code-highlight-string-color:#718c00;--code-highlight-literal-color:#c82829;--code-highlight-attribute-color:#c82829;--code-highlight-self-color:#c82829;--code-highlight-macro-color:#3e999f;--code-highlight-question-mark-color:#ff9011;--code-highlight-comment-color:#8e908c;--code-highlight-doc-comment-color:#4d4d4c;--src-line-numbers-span-color:#c67e2d;--src-line-number-highlighted-background-color:#fdffd3;--test-arrow-color:#f5f5f5;--test-arrow-background-color:rgba(78,139,202,0.2);--test-arrow-hover-color:#f5f5f5;--test-arrow-hover-background-color:rgb(78,139,202);--target-background-color:#fdffd3;--target-border-color:#ad7c37;--kbd-color:#000;--kbd-background:#fafbfc;--kbd-box-shadow-color:#c6cbd1;--rust-logo-filter:initial;--crate-search-div-filter:invert(100%) sepia(0%) saturate(4223%) hue-rotate(289deg) brightness(114%) contrast(76%);--crate-search-div-hover-filter:invert(44%) sepia(18%) saturate(23%) hue-rotate(317deg) brightness(96%) contrast(93%);--crate-search-hover-border:#717171;--src-sidebar-background-selected:#fff;--src-sidebar-background-hover:#e0e0e0;--table-alt-row-background-color:#f5f5f5;--codeblock-link-background:#eee;--scrape-example-toggle-line-background:#ccc;--scrape-example-toggle-line-hover-background:#999;--scrape-example-code-line-highlight:#fcffd6;--scrape-example-code-line-highlight-focus:#f6fdb0;--scrape-example-help-border-color:#555;--scrape-example-help-color:#333;--scrape-example-help-hover-border-color:#000;--scrape-example-help-hover-color:#000;--scrape-example-code-wrapper-background-start:rgba(255,255,255,1);--scrape-example-code-wrapper-background-end:rgba(255,255,255,0);}@media (prefers-color-scheme:dark){:root{--main-background-color:#353535;--main-color:#ddd;--settings-input-color:#2196f3;--settings-input-border-color:#999;--settings-button-color:#000;--settings-button-border-focus:#ffb900;--sidebar-background-color:#505050;--sidebar-background-color-hover:#676767;--code-block-background-color:#2A2A2A;--scrollbar-track-background-color:#717171;--scrollbar-thumb-background-color:rgba(32,34,37,.6);--scrollbar-color:rgba(32,34,37,.6) #5a5a5a;--headings-border-bottom-color:#d2d2d2;--border-color:#e0e0e0;--button-background-color:#f0f0f0;--right-side-color:grey;--code-attribute-color:#999;--toggles-color:#999;--toggle-filter:invert(100%);--search-input-focused-border-color:#008dfd;--copy-path-button-color:#999;--copy-path-img-filter:invert(50%);--copy-path-img-hover-filter:invert(65%);--codeblock-error-hover-color:rgb(255,0,0);--codeblock-error-color:rgba(255,0,0,.5);--codeblock-ignore-hover-color:rgb(255,142,0);--codeblock-ignore-color:rgba(255,142,0,.6);--warning-border-color:#ff8e00;--type-link-color:#2dbfb8;--trait-link-color:#b78cf2;--assoc-item-link-color:#d2991d;--function-link-color:#2bab63;--macro-link-color:#09bd00;--keyword-link-color:#d2991d;--mod-link-color:#d2991d;--link-color:#d2991d;--sidebar-link-color:#fdbf35;--sidebar-current-link-background-color:#444;--search-result-link-focus-background-color:#616161;--search-result-border-color:#aaa3;--search-color:#111;--search-error-code-background-color:#484848;--search-results-alias-color:#fff;--search-results-grey-color:#ccc;--search-tab-title-count-color:#888;--search-tab-button-not-selected-border-top-color:#252525;--search-tab-button-not-selected-background:#252525;--search-tab-button-selected-border-top-color:#0089ff;--search-tab-button-selected-background:#353535;--stab-background-color:#314559;--stab-code-color:#e6e1cf;--code-highlight-kw-color:#ab8ac1;--code-highlight-kw-2-color:#769acb;--code-highlight-lifetime-color:#d97f26;--code-highlight-prelude-color:#769acb;--code-highlight-prelude-val-color:#ee6868;--code-highlight-number-color:#83a300;--code-highlight-string-color:#83a300;--code-highlight-literal-color:#ee6868;--code-highlight-attribute-color:#ee6868;--code-highlight-self-color:#ee6868;--code-highlight-macro-color:#3e999f;--code-highlight-question-mark-color:#ff9011;--code-highlight-comment-color:#8d8d8b;--code-highlight-doc-comment-color:#8ca375;--src-line-numbers-span-color:#3b91e2;--src-line-number-highlighted-background-color:#0a042f;--test-arrow-color:#dedede;--test-arrow-background-color:rgba(78,139,202,0.2);--test-arrow-hover-color:#dedede;--test-arrow-hover-background-color:#4e8bca;--target-background-color:#494a3d;--target-border-color:#bb7410;--kbd-color:#000;--kbd-background:#fafbfc;--kbd-box-shadow-color:#c6cbd1;--rust-logo-filter:drop-shadow(1px 0 0px #fff) drop-shadow(0 1px 0 #fff) drop-shadow(-1px 0 0 #fff) drop-shadow(0 -1px 0 #fff);--crate-search-div-filter:invert(94%) sepia(0%) saturate(721%) hue-rotate(255deg) brightness(90%) contrast(90%);--crate-search-div-hover-filter:invert(69%) sepia(60%) saturate(6613%) hue-rotate(184deg) brightness(100%) contrast(91%);--crate-search-hover-border:#2196f3;--src-sidebar-background-selected:#333;--src-sidebar-background-hover:#444;--table-alt-row-background-color:#2a2a2a;--codeblock-link-background:#333;--scrape-example-toggle-line-background:#999;--scrape-example-toggle-line-hover-background:#c5c5c5;--scrape-example-code-line-highlight:#5b3b01;--scrape-example-code-line-highlight-focus:#7c4b0f;--scrape-example-help-border-color:#aaa;--scrape-example-help-color:#eee;--scrape-example-help-hover-border-color:#fff;--scrape-example-help-hover-color:#fff;--scrape-example-code-wrapper-background-start:rgba(53,53,53,1);--scrape-example-code-wrapper-background-end:rgba(53,53,53,0);}} \ No newline at end of file diff --git a/ch5/rust-logo.svg b/ch5/static.files/rust-logo-151179464ae7ed46.svg similarity index 100% rename from ch5/rust-logo.svg rename to ch5/static.files/rust-logo-151179464ae7ed46.svg diff --git a/ch5/static.files/rustdoc-fa3bb1812debf86c.css b/ch5/static.files/rustdoc-fa3bb1812debf86c.css new file mode 100644 index 00000000..2dd5cebc --- /dev/null +++ b/ch5/static.files/rustdoc-fa3bb1812debf86c.css @@ -0,0 +1,10 @@ + :root{--nav-sub-mobile-padding:8px;--search-typename-width:6.75rem;}@font-face {font-family:'Fira Sans';font-style:normal;font-weight:400;src:local('Fira Sans'),url("FiraSans-Regular-018c141bf0843ffd.woff2") format("woff2");font-display:swap;}@font-face {font-family:'Fira Sans';font-style:normal;font-weight:500;src:local('Fira Sans Medium'),url("FiraSans-Medium-8f9a781e4970d388.woff2") format("woff2");font-display:swap;}@font-face {font-family:'Source Serif 4';font-style:normal;font-weight:400;src:local('Source Serif 4'),url("SourceSerif4-Regular-46f98efaafac5295.ttf.woff2") format("woff2");font-display:swap;}@font-face {font-family:'Source Serif 4';font-style:italic;font-weight:400;src:local('Source Serif 4 Italic'),url("SourceSerif4-It-acdfaf1a8af734b1.ttf.woff2") format("woff2");font-display:swap;}@font-face {font-family:'Source Serif 4';font-style:normal;font-weight:700;src:local('Source Serif 4 Bold'),url("SourceSerif4-Bold-a2c9cd1067f8b328.ttf.woff2") format("woff2");font-display:swap;}@font-face {font-family:'Source Code Pro';font-style:normal;font-weight:400;src:url("SourceCodePro-Regular-562dcc5011b6de7d.ttf.woff2") format("woff2");font-display:swap;}@font-face {font-family:'Source Code Pro';font-style:italic;font-weight:400;src:url("SourceCodePro-It-1cc31594bf4f1f79.ttf.woff2") format("woff2");font-display:swap;}@font-face {font-family:'Source Code Pro';font-style:normal;font-weight:600;src:url("SourceCodePro-Semibold-d899c5a5c4aeb14a.ttf.woff2") format("woff2");font-display:swap;}@font-face {font-family:'NanumBarunGothic';src:url("NanumBarunGothic-0f09457c7a19b7c6.ttf.woff2") format("woff2");font-display:swap;unicode-range:U+AC00-D7AF,U+1100-11FF,U+3130-318F,U+A960-A97F,U+D7B0-D7FF;}*{box-sizing:border-box;}body{font:1rem/1.5 "Source Serif 4",NanumBarunGothic,serif;margin:0;position:relative;overflow-wrap:break-word;overflow-wrap:anywhere;font-feature-settings:"kern","liga";background-color:var(--main-background-color);color:var(--main-color);}h1{font-size:1.5rem;}h2{font-size:1.375rem;}h3{font-size:1.25rem;}h1,h2,h3,h4,h5,h6{font-weight:500;}h1,h2,h3,h4{margin:25px 0 15px 0;padding-bottom:6px;}.docblock h3,.docblock h4,h5,h6{margin:15px 0 5px 0;}.docblock>h2:first-child,.docblock>h3:first-child,.docblock>h4:first-child,.docblock>h5:first-child,.docblock>h6:first-child{margin-top:0;}.main-heading h1{margin:0;padding:0;flex-grow:1;overflow-wrap:break-word;overflow-wrap:anywhere;}.main-heading{display:flex;flex-wrap:wrap;padding-bottom:6px;margin-bottom:15px;}.content h2,.top-doc .docblock>h3,.top-doc .docblock>h4{border-bottom:1px solid var(--headings-border-bottom-color);}h1,h2{line-height:1.25;padding-top:3px;padding-bottom:9px;}h3.code-header{font-size:1.125rem;}h4.code-header{font-size:1rem;}.code-header{font-weight:600;margin:0;padding:0;white-space:pre-wrap;}#crate-search,h1,h2,h3,h4,h5,h6,.sidebar,.mobile-topbar,.search-input,.search-results .result-name,.item-name>a,.out-of-band,span.since,a.src,#help-button>a,summary.hideme,.scraped-example-list,ul.all-items{font-family:"Fira Sans",Arial,NanumBarunGothic,sans-serif;}#toggle-all-docs,a.anchor,.small-section-header a,#src-sidebar a,.rust a,.sidebar h2 a,.sidebar h3 a,.mobile-topbar h2 a,h1 a,.search-results a,.stab,.result-name i{color:var(--main-color);}span.enum,a.enum,span.struct,a.struct,span.union,a.union,span.primitive,a.primitive,span.type,a.type,span.foreigntype,a.foreigntype{color:var(--type-link-color);}span.trait,a.trait,span.traitalias,a.traitalias{color:var(--trait-link-color);}span.associatedtype,a.associatedtype,span.constant,a.constant,span.static,a.static{color:var(--assoc-item-link-color);}span.fn,a.fn,span.method,a.method,span.tymethod,a.tymethod{color:var(--function-link-color);}span.attr,a.attr,span.derive,a.derive,span.macro,a.macro{color:var(--macro-link-color);}span.mod,a.mod{color:var(--mod-link-color);}span.keyword,a.keyword{color:var(--keyword-link-color);}a{color:var(--link-color);text-decoration:none;}ol,ul{padding-left:24px;}ul ul,ol ul,ul ol,ol ol{margin-bottom:.625em;}p,.docblock>.warning{margin:0 0 .75em 0;}p:last-child,.docblock>.warning:last-child{margin:0;}button{padding:1px 6px;cursor:pointer;}button#toggle-all-docs{padding:0;background:none;border:none;-webkit-appearance:none;opacity:1;}.rustdoc{display:flex;flex-direction:row;flex-wrap:nowrap;}main{position:relative;flex-grow:1;padding:10px 15px 40px 45px;min-width:0;}.src main{padding:15px;}.width-limiter{max-width:960px;margin-right:auto;}details:not(.toggle) summary{margin-bottom:.6em;}code,pre,a.test-arrow,.code-header{font-family:"Source Code Pro",monospace;}.docblock code,.docblock-short code{border-radius:3px;padding:0 0.125em;}.docblock pre code,.docblock-short pre code{padding:0;}pre{padding:14px;line-height:1.5;}pre.item-decl{overflow-x:auto;}.item-decl .type-contents-toggle{contain:initial;}.src .content pre{padding:20px;}.rustdoc.src .example-wrap pre.src-line-numbers{padding:20px 0 20px 4px;}img{max-width:100%;}.sub-logo-container,.logo-container{line-height:0;display:block;}.sub-logo-container{margin-right:32px;}.sub-logo-container>img{height:60px;width:60px;object-fit:contain;}.rust-logo{filter:var(--rust-logo-filter);}.sidebar{font-size:0.875rem;flex:0 0 200px;overflow-y:scroll;overscroll-behavior:contain;position:sticky;height:100vh;top:0;left:0;}.rustdoc.src .sidebar{flex-basis:50px;border-right:1px solid;overflow-x:hidden;overflow-y:hidden;z-index:1;}.sidebar,.mobile-topbar,.sidebar-menu-toggle,#src-sidebar-toggle,#src-sidebar{background-color:var(--sidebar-background-color);}#src-sidebar-toggle>button:hover,#src-sidebar-toggle>button:focus{background-color:var(--sidebar-background-color-hover);}.src .sidebar>*:not(#src-sidebar-toggle){visibility:hidden;}.src-sidebar-expanded .src .sidebar{overflow-y:auto;flex-basis:300px;}.src-sidebar-expanded .src .sidebar>*:not(#src-sidebar-toggle){visibility:visible;}#all-types{margin-top:1em;}*{scrollbar-width:initial;scrollbar-color:var(--scrollbar-color);}.sidebar{scrollbar-width:thin;scrollbar-color:var(--scrollbar-color);}::-webkit-scrollbar{width:12px;}.sidebar::-webkit-scrollbar{width:8px;}::-webkit-scrollbar-track{-webkit-box-shadow:inset 0;background-color:var(--scrollbar-track-background-color);}.sidebar::-webkit-scrollbar-track{background-color:var(--scrollbar-track-background-color);}::-webkit-scrollbar-thumb,.sidebar::-webkit-scrollbar-thumb{background-color:var(--scrollbar-thumb-background-color);}.hidden{display:none !important;}.sidebar .logo-container{margin-top:10px;margin-bottom:10px;text-align:center;}.version{overflow-wrap:break-word;}.logo-container>img{height:100px;width:100px;}ul.block,.block li{padding:0;margin:0;list-style:none;}.sidebar-elems a,.sidebar>h2 a{display:block;padding:0.25rem;margin-left:-0.25rem;}.sidebar h2{overflow-wrap:anywhere;padding:0;margin:0.7rem 0;}.sidebar h3{font-size:1.125rem;padding:0;margin:0;}.sidebar-elems,.sidebar>h2{padding-left:24px;}.sidebar a{color:var(--sidebar-link-color);}.sidebar .current,.sidebar a:hover:not(.logo-container){background-color:var(--sidebar-current-link-background-color);}.sidebar-elems .block{margin-bottom:2em;}.sidebar-elems .block li a{white-space:nowrap;text-overflow:ellipsis;overflow:hidden;}.mobile-topbar{display:none;}.rustdoc .example-wrap{display:flex;position:relative;margin-bottom:10px;}.rustdoc .example-wrap:last-child{margin-bottom:0px;}.rustdoc .example-wrap pre{margin:0;flex-grow:1;}.rustdoc:not(.src) .example-wrap pre{overflow:auto hidden;}.rustdoc .example-wrap pre.example-line-numbers,.rustdoc .example-wrap pre.src-line-numbers{flex-grow:0;min-width:fit-content;overflow:initial;text-align:right;-webkit-user-select:none;user-select:none;padding:14px 8px;color:var(--src-line-numbers-span-color);}.rustdoc .example-wrap pre.src-line-numbers{padding:14px 0;}.src-line-numbers a,.src-line-numbers span{color:var(--src-line-numbers-span-color);padding:0 8px;}.src-line-numbers :target{background-color:transparent;border-right:none;padding:0 8px;}.src-line-numbers .line-highlighted{background-color:var(--src-line-number-highlighted-background-color);}.search-loading{text-align:center;}.docblock-short{overflow-wrap:break-word;overflow-wrap:anywhere;}.docblock :not(pre)>code,.docblock-short code{white-space:pre-wrap;}.top-doc .docblock h2{font-size:1.375rem;}.top-doc .docblock h3{font-size:1.25rem;}.top-doc .docblock h4,.top-doc .docblock h5{font-size:1.125rem;}.top-doc .docblock h6{font-size:1rem;}.docblock h5{font-size:1rem;}.docblock h6{font-size:0.875rem;}.docblock{margin-left:24px;position:relative;}.docblock>:not(.more-examples-toggle):not(.example-wrap){max-width:100%;overflow-x:auto;}.out-of-band{flex-grow:0;font-size:1.125rem;}.docblock code,.docblock-short code,pre,.rustdoc.src .example-wrap{background-color:var(--code-block-background-color);}#main-content{position:relative;}.docblock table{margin:.5em 0;border-collapse:collapse;}.docblock table td,.docblock table th{padding:.5em;border:1px solid var(--border-color);}.docblock table tbody tr:nth-child(2n){background:var(--table-alt-row-background-color);}.method .where,.fn .where,.where.fmt-newline{display:block;white-space:pre-wrap;font-size:0.875rem;}.item-info{display:block;margin-left:24px;}.item-info code{font-size:0.875rem;}#main-content>.item-info{margin-left:0;}nav.sub{flex-grow:1;flex-flow:row nowrap;margin:4px 0 25px 0;display:flex;align-items:center;}.search-form{position:relative;display:flex;height:34px;flex-grow:1;}.src nav.sub{margin:0 0 15px 0;}.small-section-header{display:block;position:relative;}.small-section-header:hover>.anchor,.impl:hover>.anchor,.trait-impl:hover>.anchor,.variant:hover>.anchor{display:initial;}.anchor{display:none;position:absolute;left:-0.5em;background:none !important;}.anchor.field{left:-5px;}.small-section-header>.anchor{left:-15px;padding-right:8px;}h2.small-section-header>.anchor{padding-right:6px;}.main-heading a:hover,.example-wrap .rust a:hover,.all-items a:hover,.docblock a:not(.test-arrow):not(.scrape-help):not(.tooltip):hover,.docblock-short a:not(.test-arrow):not(.scrape-help):not(.tooltip):hover,.item-info a{text-decoration:underline;}.crate.block a.current{font-weight:500;}table,.item-table{overflow-wrap:break-word;}.item-table{display:table;padding:0;margin:0;}.item-table>li{display:table-row;}.item-table>li>div{display:table-cell;}.item-table>li>.item-name{padding-right:1.25rem;}.search-results-title{margin-top:0;white-space:nowrap;display:flex;align-items:baseline;}#crate-search-div{position:relative;min-width:5em;}#crate-search{min-width:115px;padding:0 23px 0 4px;max-width:100%;text-overflow:ellipsis;border:1px solid var(--border-color);border-radius:4px;outline:none;cursor:pointer;-moz-appearance:none;-webkit-appearance:none;text-indent:0.01px;background-color:var(--main-background-color);color:inherit;line-height:1.5;font-weight:500;}#crate-search:hover,#crate-search:focus{border-color:var(--crate-search-hover-border);}#crate-search-div::after{pointer-events:none;width:100%;height:100%;position:absolute;top:0;left:0;content:"";background-repeat:no-repeat;background-size:20px;background-position:calc(100% - 2px) 56%;background-image:url('data:image/svg+xml, \ + ');filter:var(--crate-search-div-filter);}#crate-search-div:hover::after,#crate-search-div:focus-within::after{filter:var(--crate-search-div-hover-filter);}#crate-search>option{font-size:1rem;}.search-input{-webkit-appearance:none;outline:none;border:1px solid var(--border-color);border-radius:2px;padding:8px;font-size:1rem;flex-grow:1;background-color:var(--button-background-color);color:var(--search-color);}.search-input:focus{border-color:var(--search-input-focused-border-color);}.search-results{display:none;}.search-results.active{display:block;}.search-results>a{display:flex;margin-left:2px;margin-right:2px;border-bottom:1px solid var(--search-result-border-color);gap:1em;}.search-results>a>div.desc{white-space:nowrap;text-overflow:ellipsis;overflow:hidden;flex:2;}.search-results a:hover,.search-results a:focus{background-color:var(--search-result-link-focus-background-color);}.search-results .result-name{display:flex;align-items:center;justify-content:start;flex:3;}.search-results .result-name .alias{color:var(--search-results-alias-color);}.search-results .result-name .grey{color:var(--search-results-grey-color);}.search-results .result-name .typename{color:var(--search-results-grey-color);font-size:0.875rem;width:var(--search-typename-width);}.search-results .result-name .path{word-break:break-all;max-width:calc(100% - var(--search-typename-width));display:inline-block;}.search-results .result-name .path>*{display:inline;}.popover{position:absolute;top:100%;right:0;z-index:2;margin-top:7px;border-radius:3px;border:1px solid var(--border-color);background-color:var(--main-background-color);color:var(--main-color);--popover-arrow-offset:11px;}.popover::before{content:'';position:absolute;right:var(--popover-arrow-offset);border:solid var(--border-color);border-width:1px 1px 0 0;background-color:var(--main-background-color);padding:4px;transform:rotate(-45deg);top:-5px;}.setting-line{margin:1.2em 0.6em;}.setting-radio input,.setting-check input{margin-right:0.3em;height:1.2rem;width:1.2rem;border:2px solid var(--settings-input-border-color);outline:none;-webkit-appearance:none;cursor:pointer;}.setting-radio input{border-radius:50%;}.setting-radio span,.setting-check span{padding-bottom:1px;}.setting-radio{margin-top:0.1em;margin-bottom:0.1em;min-width:3.8em;padding:0.3em;display:inline-flex;align-items:center;cursor:pointer;}.setting-radio+.setting-radio{margin-left:0.5em;}.setting-check{margin-right:20px;display:flex;align-items:center;cursor:pointer;}.setting-radio input:checked{box-shadow:inset 0 0 0 3px var(--main-background-color);background-color:var(--settings-input-color);}.setting-check input:checked{background-color:var(--settings-input-color);border-width:1px;content:url('data:image/svg+xml,\ + \ + ');}.setting-radio input:focus,.setting-check input:focus{box-shadow:0 0 1px 1px var(--settings-input-color);}.setting-radio input:checked:focus{box-shadow:inset 0 0 0 3px var(--main-background-color),0 0 2px 2px var(--settings-input-color);}.setting-radio input:hover,.setting-check input:hover{border-color:var(--settings-input-color) !important;}#help.popover{max-width:600px;--popover-arrow-offset:48px;}#help dt{float:left;clear:left;margin-right:0.5rem;}#help span.top,#help span.bottom{text-align:center;display:block;font-size:1.125rem;}#help span.top{margin:10px 0;border-bottom:1px solid var(--border-color);padding-bottom:4px;margin-bottom:6px;}#help span.bottom{clear:both;border-top:1px solid var(--border-color);}.side-by-side>div{width:50%;float:left;padding:0 20px 20px 17px;}.item-info .stab{min-height:36px;display:flex;padding:3px;margin-bottom:5px;align-items:center;vertical-align:text-bottom;}.item-name .stab{margin-left:0.3125em;}.stab{padding:0 2px;font-size:0.875rem;font-weight:normal;color:var(--main-color);background-color:var(--stab-background-color);width:fit-content;white-space:pre-wrap;border-radius:3px;display:inline;}.stab.portability>code{background:none;color:var(--stab-code-color);}.stab .emoji{font-size:1.25rem;margin-right:0.3rem;}.emoji{text-shadow:1px 0 0 black,-1px 0 0 black,0 1px 0 black,0 -1px 0 black;}.since{font-weight:normal;font-size:initial;}.rightside{padding-left:12px;float:right;}.rightside:not(a),.out-of-band{color:var(--right-side-color);}pre.rust{tab-size:4;-moz-tab-size:4;}pre.rust .kw{color:var(--code-highlight-kw-color);}pre.rust .kw-2{color:var(--code-highlight-kw-2-color);}pre.rust .lifetime{color:var(--code-highlight-lifetime-color);}pre.rust .prelude-ty{color:var(--code-highlight-prelude-color);}pre.rust .prelude-val{color:var(--code-highlight-prelude-val-color);}pre.rust .string{color:var(--code-highlight-string-color);}pre.rust .number{color:var(--code-highlight-number-color);}pre.rust .bool-val{color:var(--code-highlight-literal-color);}pre.rust .self{color:var(--code-highlight-self-color);}pre.rust .attr{color:var(--code-highlight-attribute-color);}pre.rust .macro,pre.rust .macro-nonterminal{color:var(--code-highlight-macro-color);}pre.rust .question-mark{font-weight:bold;color:var(--code-highlight-question-mark-color);}pre.rust .comment{color:var(--code-highlight-comment-color);}pre.rust .doccomment{color:var(--code-highlight-doc-comment-color);}.rustdoc.src .example-wrap pre.rust a{background:var(--codeblock-link-background);}.example-wrap.compile_fail,.example-wrap.should_panic{border-left:2px solid var(--codeblock-error-color);}.ignore.example-wrap{border-left:2px solid var(--codeblock-ignore-color);}.example-wrap.compile_fail:hover,.example-wrap.should_panic:hover{border-left:2px solid var(--codeblock-error-hover-color);}.example-wrap.ignore:hover{border-left:2px solid var(--codeblock-ignore-hover-color);}.example-wrap.compile_fail .tooltip,.example-wrap.should_panic .tooltip{color:var(--codeblock-error-color);}.example-wrap.ignore .tooltip{color:var(--codeblock-ignore-color);}.example-wrap.compile_fail:hover .tooltip,.example-wrap.should_panic:hover .tooltip{color:var(--codeblock-error-hover-color);}.example-wrap.ignore:hover .tooltip{color:var(--codeblock-ignore-hover-color);}.example-wrap .tooltip{position:absolute;display:block;left:-25px;top:5px;margin:0;line-height:1;}.example-wrap.compile_fail .tooltip,.example-wrap.should_panic .tooltip,.example-wrap.ignore .tooltip{font-weight:bold;font-size:1.25rem;}.content .docblock .warning{border-left:2px solid var(--warning-border-color);padding:14px;position:relative;overflow-x:visible !important;}.content .docblock .warning::before{color:var(--warning-border-color);content:"ⓘ";position:absolute;left:-25px;top:5px;font-weight:bold;font-size:1.25rem;}a.test-arrow{visibility:hidden;position:absolute;padding:5px 10px 5px 10px;border-radius:5px;font-size:1.375rem;top:5px;right:5px;z-index:1;color:var(--test-arrow-color);background-color:var(--test-arrow-background-color);}a.test-arrow:hover{color:var(--test-arrow-hover-color);background-color:var(--test-arrow-hover-background-color);}.example-wrap:hover .test-arrow{visibility:visible;}.code-attribute{font-weight:300;color:var(--code-attribute-color);}.item-spacer{width:100%;height:12px;display:block;}.out-of-band>span.since{font-size:1.25rem;}.sub-variant h4{font-size:1rem;font-weight:400;margin-top:0;margin-bottom:0;}.sub-variant{margin-left:24px;margin-bottom:40px;}.sub-variant>.sub-variant-field{margin-left:24px;}:target{padding-right:3px;background-color:var(--target-background-color);border-right:3px solid var(--target-border-color);}.code-header a.tooltip{color:inherit;margin-right:15px;position:relative;}.code-header a.tooltip:hover{color:var(--link-color);}a.tooltip:hover::after{position:absolute;top:calc(100% - 10px);left:-15px;right:-15px;height:20px;content:"\00a0";}.fade-out{opacity:0;transition:opacity 0.45s cubic-bezier(0,0,0.1,1.0);}.popover.tooltip .content{margin:0.25em 0.5em;}.popover.tooltip .content pre,.popover.tooltip .content code{background:transparent;margin:0;padding:0;font-size:1.25rem;white-space:pre-wrap;}.popover.tooltip .content>h3:first-child{margin:0 0 5px 0;}.search-failed{text-align:center;margin-top:20px;display:none;}.search-failed.active{display:block;}.search-failed>ul{text-align:left;max-width:570px;margin-left:auto;margin-right:auto;}#search-tabs{display:flex;flex-direction:row;gap:1px;margin-bottom:4px;}#search-tabs button{text-align:center;font-size:1.125rem;border:0;border-top:2px solid;flex:1;line-height:1.5;color:inherit;}#search-tabs button:not(.selected){background-color:var(--search-tab-button-not-selected-background);border-top-color:var(--search-tab-button-not-selected-border-top-color);}#search-tabs button:hover,#search-tabs button.selected{background-color:var(--search-tab-button-selected-background);border-top-color:var(--search-tab-button-selected-border-top-color);}#search-tabs .count{font-size:1rem;font-variant-numeric:tabular-nums;color:var(--search-tab-title-count-color);}#search .error code{border-radius:3px;background-color:var(--search-error-code-background-color);}.search-corrections{font-weight:normal;}#src-sidebar-toggle{position:sticky;top:0;left:0;font-size:1.25rem;border-bottom:1px solid;display:flex;height:40px;justify-content:stretch;align-items:stretch;z-index:10;}#src-sidebar{width:100%;overflow:auto;}#src-sidebar>.title{font-size:1.5rem;text-align:center;border-bottom:1px solid var(--border-color);margin-bottom:6px;}#src-sidebar div.files>a:hover,details.dir-entry summary:hover,#src-sidebar div.files>a:focus,details.dir-entry summary:focus{background-color:var(--src-sidebar-background-hover);}#src-sidebar div.files>a.selected{background-color:var(--src-sidebar-background-selected);}#src-sidebar-toggle>button{font-size:inherit;font-weight:bold;background:none;color:inherit;text-align:center;border:none;outline:none;flex:1 1;-webkit-appearance:none;opacity:1;}#settings-menu,#help-button{margin-left:4px;display:flex;}#settings-menu>a,#help-button>a{display:flex;align-items:center;justify-content:center;background-color:var(--button-background-color);border:1px solid var(--border-color);border-radius:2px;color:var(--settings-button-color);font-size:20px;width:33px;}#settings-menu>a:hover,#settings-menu>a:focus,#help-button>a:hover,#help-button>a:focus{border-color:var(--settings-button-border-focus);}#copy-path{color:var(--copy-path-button-color);background:var(--main-background-color);height:34px;margin-left:10px;padding:0;padding-left:2px;border:0;width:33px;}#copy-path>img{filter:var(--copy-path-img-filter);}#copy-path:hover>img{filter:var(--copy-path-img-hover-filter);}@keyframes rotating{from{transform:rotate(0deg);}to{transform:rotate(360deg);}}#settings-menu.rotate>a img{animation:rotating 2s linear infinite;}kbd{display:inline-block;padding:3px 5px;font:15px monospace;line-height:10px;vertical-align:middle;border:solid 1px var(--border-color);border-radius:3px;color:var(--kbd-color);background-color:var(--kbd-background);box-shadow:inset 0 -1px 0 var(--kbd-box-shadow-color);}ul.all-items>li{list-style:none;}details.dir-entry{padding-left:4px;}details.dir-entry>summary{margin:0 0 0 -4px;padding:0 0 0 4px;cursor:pointer;}details.dir-entry div.folders,details.dir-entry div.files{padding-left:23px;}details.dir-entry a{display:block;}details.toggle{contain:layout;position:relative;}details.toggle>summary.hideme{cursor:pointer;font-size:1rem;}details.toggle>summary{list-style:none;outline:none;}details.toggle>summary::-webkit-details-marker,details.toggle>summary::marker{display:none;}details.toggle>summary.hideme>span{margin-left:9px;}details.toggle>summary::before{background:url('data:image/svg+xml,') no-repeat top left;content:"";cursor:pointer;width:16px;height:16px;display:inline-block;vertical-align:middle;opacity:.5;filter:var(--toggle-filter);}details.toggle>summary.hideme>span,.more-examples-toggle summary,.more-examples-toggle .hide-more{color:var(--toggles-color);}details.toggle>summary::after{content:"Expand";overflow:hidden;width:0;height:0;position:absolute;}details.toggle>summary.hideme::after{content:"";}details.toggle>summary:focus::before,details.toggle>summary:hover::before{opacity:1;}details.toggle>summary:focus-visible::before{outline:1px dotted #000;outline-offset:1px;}details.non-exhaustive{margin-bottom:8px;}details.toggle>summary.hideme::before{position:relative;}details.toggle>summary:not(.hideme)::before{position:absolute;left:-24px;top:4px;}.impl-items>details.toggle>summary:not(.hideme)::before{position:absolute;left:-24px;}details.toggle[open] >summary.hideme{position:absolute;}details.toggle[open] >summary.hideme>span{display:none;}details.toggle[open] >summary::before{background:url('data:image/svg+xml,') no-repeat top left;}details.toggle[open] >summary::after{content:"Collapse";}.docblock summary>*{display:inline-block;}.docblock>.example-wrap:first-child .tooltip{margin-top:16px;}@media (max-width:850px){#search-tabs .count{display:block;}}@media (max-width:700px){*[id]{scroll-margin-top:45px;}.rustdoc{display:block;}main{padding-left:15px;padding-top:0px;}.main-heading{flex-direction:column;}.out-of-band{text-align:left;margin-left:initial;padding:initial;}.out-of-band .since::before{content:"Since ";}.sidebar .logo-container,.sidebar .location{display:none;}.sidebar{position:fixed;top:45px;left:-1000px;z-index:11;height:calc(100vh - 45px);width:200px;}.src main,.rustdoc.src .sidebar{top:0;padding:0;height:100vh;border:0;}.sidebar.shown,.src-sidebar-expanded .src .sidebar,.rustdoc:not(.src) .sidebar:focus-within{left:0;}.mobile-topbar h2{padding-bottom:0;margin:auto 0.5em auto auto;overflow:hidden;font-size:24px;}.mobile-topbar h2 a{display:block;text-overflow:ellipsis;overflow:hidden;white-space:nowrap;}.mobile-topbar .logo-container>img{max-width:35px;max-height:35px;margin:5px 0 5px 20px;}.mobile-topbar{display:flex;flex-direction:row;position:sticky;z-index:10;font-size:2rem;height:45px;width:100%;left:0;top:0;}.sidebar-menu-toggle{width:45px;font-size:32px;border:none;color:var(--main-color);}.sidebar-elems{margin-top:1em;}.anchor{display:none !important;}#main-content>details.toggle>summary::before,#main-content>div>details.toggle>summary::before{left:-11px;}#src-sidebar-toggle{position:fixed;left:1px;top:100px;width:30px;font-size:1.5rem;padding:0;z-index:10;border-top-right-radius:3px;border-bottom-right-radius:3px;border:1px solid;border-left:0;}.src-sidebar-expanded #src-sidebar-toggle{left:unset;top:unset;width:unset;border-top-right-radius:unset;border-bottom-right-radius:unset;position:sticky;border:0;border-bottom:1px solid;}#copy-path,#help-button{display:none;}.item-table,.item-row,.item-table>li,.item-table>li>div,.search-results>a,.search-results>a>div{display:block;}.search-results>a{padding:5px 0px;}.search-results>a>div.desc,.item-table>li>div.desc{padding-left:2em;}.search-results .result-name{display:block;}.search-results .result-name .typename{width:initial;margin-right:0;}.search-results .result-name .typename,.search-results .result-name .path{display:inline;}.src-sidebar-expanded .src .sidebar{max-width:100vw;width:100vw;}details.toggle:not(.top-doc)>summary{margin-left:10px;}.impl-items>details.toggle>summary:not(.hideme)::before,#main-content>details.toggle:not(.top-doc)>summary::before,#main-content>div>details.toggle>summary::before{left:-11px;}.impl-items>.item-info{margin-left:34px;}.src nav.sub{margin:0;padding:var(--nav-sub-mobile-padding);}}@media (min-width:701px){.scraped-example-title{position:absolute;z-index:10;background:var(--main-background-color);bottom:8px;right:5px;padding:2px 4px;box-shadow:0 0 4px var(--main-background-color);}}@media print{nav.sidebar,nav.sub,.out-of-band,a.src,#copy-path,details.toggle[open] >summary::before,details.toggle>summary::before,details.toggle.top-doc>summary{display:none;}.docblock{margin-left:0;}main{padding:10px;}}@media (max-width:464px){.docblock{margin-left:12px;}.docblock code{overflow-wrap:break-word;overflow-wrap:anywhere;}nav.sub{flex-direction:column;}.search-form{align-self:stretch;}.sub-logo-container>img{height:35px;width:35px;margin-bottom:var(--nav-sub-mobile-padding);}}.variant,.implementors-toggle>summary,.impl,#implementors-list>.docblock,.impl-items>section,.impl-items>.toggle>summary,.methods>section,.methods>.toggle>summary{margin-bottom:0.75em;}.variants>.docblock,.implementors-toggle>.docblock,.impl-items>.toggle[open]:not(:last-child),.methods>.toggle[open]:not(:last-child),.implementors-toggle[open]:not(:last-child){margin-bottom:2em;}#trait-implementations-list .impl-items>.toggle:not(:last-child),#synthetic-implementations-list .impl-items>.toggle:not(:last-child),#blanket-implementations-list .impl-items>.toggle:not(:last-child){margin-bottom:1em;}.scraped-example-list .scrape-help{margin-left:10px;padding:0 4px;font-weight:normal;font-size:12px;position:relative;bottom:1px;border:1px solid var(--scrape-example-help-border-color);border-radius:50px;color:var(--scrape-example-help-color);}.scraped-example-list .scrape-help:hover{border-color:var(--scrape-example-help-hover-border-color);color:var(--scrape-example-help-hover-color);}.scraped-example{position:relative;}.scraped-example .code-wrapper{position:relative;display:flex;flex-direction:row;flex-wrap:wrap;width:100%;}.scraped-example:not(.expanded) .code-wrapper{max-height:calc(1.5em * 5 + 10px);}.scraped-example:not(.expanded) .code-wrapper pre{overflow-y:hidden;padding-bottom:0;max-height:calc(1.5em * 5 + 10px);}.more-scraped-examples .scraped-example:not(.expanded) .code-wrapper,.more-scraped-examples .scraped-example:not(.expanded) .code-wrapper pre{max-height:calc(1.5em * 10 + 10px);}.scraped-example .code-wrapper .next,.scraped-example .code-wrapper .prev,.scraped-example .code-wrapper .expand{color:var(--main-color);position:absolute;top:0.25em;z-index:1;padding:0;background:none;border:none;-webkit-appearance:none;opacity:1;}.scraped-example .code-wrapper .prev{right:2.25em;}.scraped-example .code-wrapper .next{right:1.25em;}.scraped-example .code-wrapper .expand{right:0.25em;}.scraped-example:not(.expanded) .code-wrapper::before,.scraped-example:not(.expanded) .code-wrapper::after{content:" ";width:100%;height:5px;position:absolute;z-index:1;}.scraped-example:not(.expanded) .code-wrapper::before{top:0;background:linear-gradient(to bottom,var(--scrape-example-code-wrapper-background-start),var(--scrape-example-code-wrapper-background-end));}.scraped-example:not(.expanded) .code-wrapper::after{bottom:0;background:linear-gradient(to top,var(--scrape-example-code-wrapper-background-start),var(--scrape-example-code-wrapper-background-end));}.scraped-example .code-wrapper .example-wrap{width:100%;overflow-y:hidden;margin-bottom:0;}.scraped-example:not(.expanded) .code-wrapper .example-wrap{overflow-x:hidden;}.scraped-example .example-wrap .rust span.highlight{background:var(--scrape-example-code-line-highlight);}.scraped-example .example-wrap .rust span.highlight.focus{background:var(--scrape-example-code-line-highlight-focus);}.more-examples-toggle{max-width:calc(100% + 25px);margin-top:10px;margin-left:-25px;}.more-examples-toggle .hide-more{margin-left:25px;cursor:pointer;}.more-scraped-examples{margin-left:25px;position:relative;}.toggle-line{position:absolute;top:5px;bottom:0;right:calc(100% + 10px);padding:0 4px;cursor:pointer;}.toggle-line-inner{min-width:2px;height:100%;background:var(--scrape-example-toggle-line-background);}.toggle-line:hover .toggle-line-inner{background:var(--scrape-example-toggle-line-hover-background);}.more-scraped-examples .scraped-example,.example-links{margin-top:20px;}.more-scraped-examples .scraped-example:first-child{margin-top:5px;}.example-links ul{margin-bottom:0;}:root[data-theme="light"]{--main-background-color:white;--main-color:black;--settings-input-color:#2196f3;--settings-input-border-color:#717171;--settings-button-color:#000;--settings-button-border-focus:#717171;--sidebar-background-color:#f5f5f5;--sidebar-background-color-hover:#e0e0e0;--code-block-background-color:#f5f5f5;--scrollbar-track-background-color:#dcdcdc;--scrollbar-thumb-background-color:rgba(36,37,39,0.6);--scrollbar-color:rgba(36,37,39,0.6) #d9d9d9;--headings-border-bottom-color:#ddd;--border-color:#e0e0e0;--button-background-color:#fff;--right-side-color:grey;--code-attribute-color:#999;--toggles-color:#999;--toggle-filter:none;--search-input-focused-border-color:#66afe9;--copy-path-button-color:#999;--copy-path-img-filter:invert(50%);--copy-path-img-hover-filter:invert(35%);--codeblock-error-hover-color:rgb(255,0,0);--codeblock-error-color:rgba(255,0,0,.5);--codeblock-ignore-hover-color:rgb(255,142,0);--codeblock-ignore-color:rgba(255,142,0,.6);--warning-border-color:#ff8e00;--type-link-color:#ad378a;--trait-link-color:#6e4fc9;--assoc-item-link-color:#3873ad;--function-link-color:#ad7c37;--macro-link-color:#068000;--keyword-link-color:#3873ad;--mod-link-color:#3873ad;--link-color:#3873ad;--sidebar-link-color:#356da4;--sidebar-current-link-background-color:#fff;--search-result-link-focus-background-color:#ccc;--search-result-border-color:#aaa3;--search-color:#000;--search-error-code-background-color:#d0cccc;--search-results-alias-color:#000;--search-results-grey-color:#999;--search-tab-title-count-color:#888;--search-tab-button-not-selected-border-top-color:#e6e6e6;--search-tab-button-not-selected-background:#e6e6e6;--search-tab-button-selected-border-top-color:#0089ff;--search-tab-button-selected-background:#fff;--stab-background-color:#fff5d6;--stab-code-color:#000;--code-highlight-kw-color:#8959a8;--code-highlight-kw-2-color:#4271ae;--code-highlight-lifetime-color:#b76514;--code-highlight-prelude-color:#4271ae;--code-highlight-prelude-val-color:#c82829;--code-highlight-number-color:#718c00;--code-highlight-string-color:#718c00;--code-highlight-literal-color:#c82829;--code-highlight-attribute-color:#c82829;--code-highlight-self-color:#c82829;--code-highlight-macro-color:#3e999f;--code-highlight-question-mark-color:#ff9011;--code-highlight-comment-color:#8e908c;--code-highlight-doc-comment-color:#4d4d4c;--src-line-numbers-span-color:#c67e2d;--src-line-number-highlighted-background-color:#fdffd3;--test-arrow-color:#f5f5f5;--test-arrow-background-color:rgba(78,139,202,0.2);--test-arrow-hover-color:#f5f5f5;--test-arrow-hover-background-color:rgb(78,139,202);--target-background-color:#fdffd3;--target-border-color:#ad7c37;--kbd-color:#000;--kbd-background:#fafbfc;--kbd-box-shadow-color:#c6cbd1;--rust-logo-filter:initial;--crate-search-div-filter:invert(100%) sepia(0%) saturate(4223%) hue-rotate(289deg) brightness(114%) contrast(76%);--crate-search-div-hover-filter:invert(44%) sepia(18%) saturate(23%) hue-rotate(317deg) brightness(96%) contrast(93%);--crate-search-hover-border:#717171;--src-sidebar-background-selected:#fff;--src-sidebar-background-hover:#e0e0e0;--table-alt-row-background-color:#f5f5f5;--codeblock-link-background:#eee;--scrape-example-toggle-line-background:#ccc;--scrape-example-toggle-line-hover-background:#999;--scrape-example-code-line-highlight:#fcffd6;--scrape-example-code-line-highlight-focus:#f6fdb0;--scrape-example-help-border-color:#555;--scrape-example-help-color:#333;--scrape-example-help-hover-border-color:#000;--scrape-example-help-hover-color:#000;--scrape-example-code-wrapper-background-start:rgba(255,255,255,1);--scrape-example-code-wrapper-background-end:rgba(255,255,255,0);}:root[data-theme="dark"]{--main-background-color:#353535;--main-color:#ddd;--settings-input-color:#2196f3;--settings-input-border-color:#999;--settings-button-color:#000;--settings-button-border-focus:#ffb900;--sidebar-background-color:#505050;--sidebar-background-color-hover:#676767;--code-block-background-color:#2A2A2A;--scrollbar-track-background-color:#717171;--scrollbar-thumb-background-color:rgba(32,34,37,.6);--scrollbar-color:rgba(32,34,37,.6) #5a5a5a;--headings-border-bottom-color:#d2d2d2;--border-color:#e0e0e0;--button-background-color:#f0f0f0;--right-side-color:grey;--code-attribute-color:#999;--toggles-color:#999;--toggle-filter:invert(100%);--search-input-focused-border-color:#008dfd;--copy-path-button-color:#999;--copy-path-img-filter:invert(50%);--copy-path-img-hover-filter:invert(65%);--codeblock-error-hover-color:rgb(255,0,0);--codeblock-error-color:rgba(255,0,0,.5);--codeblock-ignore-hover-color:rgb(255,142,0);--codeblock-ignore-color:rgba(255,142,0,.6);--warning-border-color:#ff8e00;--type-link-color:#2dbfb8;--trait-link-color:#b78cf2;--assoc-item-link-color:#d2991d;--function-link-color:#2bab63;--macro-link-color:#09bd00;--keyword-link-color:#d2991d;--mod-link-color:#d2991d;--link-color:#d2991d;--sidebar-link-color:#fdbf35;--sidebar-current-link-background-color:#444;--search-result-link-focus-background-color:#616161;--search-result-border-color:#aaa3;--search-color:#111;--search-error-code-background-color:#484848;--search-results-alias-color:#fff;--search-results-grey-color:#ccc;--search-tab-title-count-color:#888;--search-tab-button-not-selected-border-top-color:#252525;--search-tab-button-not-selected-background:#252525;--search-tab-button-selected-border-top-color:#0089ff;--search-tab-button-selected-background:#353535;--stab-background-color:#314559;--stab-code-color:#e6e1cf;--code-highlight-kw-color:#ab8ac1;--code-highlight-kw-2-color:#769acb;--code-highlight-lifetime-color:#d97f26;--code-highlight-prelude-color:#769acb;--code-highlight-prelude-val-color:#ee6868;--code-highlight-number-color:#83a300;--code-highlight-string-color:#83a300;--code-highlight-literal-color:#ee6868;--code-highlight-attribute-color:#ee6868;--code-highlight-self-color:#ee6868;--code-highlight-macro-color:#3e999f;--code-highlight-question-mark-color:#ff9011;--code-highlight-comment-color:#8d8d8b;--code-highlight-doc-comment-color:#8ca375;--src-line-numbers-span-color:#3b91e2;--src-line-number-highlighted-background-color:#0a042f;--test-arrow-color:#dedede;--test-arrow-background-color:rgba(78,139,202,0.2);--test-arrow-hover-color:#dedede;--test-arrow-hover-background-color:#4e8bca;--target-background-color:#494a3d;--target-border-color:#bb7410;--kbd-color:#000;--kbd-background:#fafbfc;--kbd-box-shadow-color:#c6cbd1;--rust-logo-filter:drop-shadow(1px 0 0px #fff) drop-shadow(0 1px 0 #fff) drop-shadow(-1px 0 0 #fff) drop-shadow(0 -1px 0 #fff);--crate-search-div-filter:invert(94%) sepia(0%) saturate(721%) hue-rotate(255deg) brightness(90%) contrast(90%);--crate-search-div-hover-filter:invert(69%) sepia(60%) saturate(6613%) hue-rotate(184deg) brightness(100%) contrast(91%);--crate-search-hover-border:#2196f3;--src-sidebar-background-selected:#333;--src-sidebar-background-hover:#444;--table-alt-row-background-color:#2a2a2a;--codeblock-link-background:#333;--scrape-example-toggle-line-background:#999;--scrape-example-toggle-line-hover-background:#c5c5c5;--scrape-example-code-line-highlight:#5b3b01;--scrape-example-code-line-highlight-focus:#7c4b0f;--scrape-example-help-border-color:#aaa;--scrape-example-help-color:#eee;--scrape-example-help-hover-border-color:#fff;--scrape-example-help-hover-color:#fff;--scrape-example-code-wrapper-background-start:rgba(53,53,53,1);--scrape-example-code-wrapper-background-end:rgba(53,53,53,0);}:root[data-theme="ayu"]{--main-background-color:#0f1419;--main-color:#c5c5c5;--settings-input-color:#ffb454;--settings-input-border-color:#999;--settings-button-color:#fff;--settings-button-border-focus:#e0e0e0;--sidebar-background-color:#14191f;--sidebar-background-color-hover:rgba(70,70,70,0.33);--code-block-background-color:#191f26;--scrollbar-track-background-color:transparent;--scrollbar-thumb-background-color:#5c6773;--scrollbar-color:#5c6773 #24292f;--headings-border-bottom-color:#5c6773;--border-color:#5c6773;--button-background-color:#141920;--right-side-color:grey;--code-attribute-color:#999;--toggles-color:#999;--toggle-filter:invert(100%);--search-input-focused-border-color:#5c6773;--copy-path-button-color:#fff;--copy-path-img-filter:invert(70%);--copy-path-img-hover-filter:invert(100%);--codeblock-error-hover-color:rgb(255,0,0);--codeblock-error-color:rgba(255,0,0,.5);--codeblock-ignore-hover-color:rgb(255,142,0);--codeblock-ignore-color:rgba(255,142,0,.6);--warning-border-color:#ff8e00;--type-link-color:#ffa0a5;--trait-link-color:#39afd7;--assoc-item-link-color:#39afd7;--function-link-color:#fdd687;--macro-link-color:#a37acc;--keyword-link-color:#39afd7;--mod-link-color:#39afd7;--link-color:#39afd7;--sidebar-link-color:#53b1db;--sidebar-current-link-background-color:transparent;--search-result-link-focus-background-color:#3c3c3c;--search-result-border-color:#aaa3;--search-color:#fff;--search-error-code-background-color:#4f4c4c;--search-results-alias-color:#c5c5c5;--search-results-grey-color:#999;--search-tab-title-count-color:#888;--search-tab-button-not-selected-border-top-color:none;--search-tab-button-not-selected-background:transparent !important;--search-tab-button-selected-border-top-color:none;--search-tab-button-selected-background:#141920 !important;--stab-background-color:#314559;--stab-code-color:#e6e1cf;--code-highlight-kw-color:#ff7733;--code-highlight-kw-2-color:#ff7733;--code-highlight-lifetime-color:#ff7733;--code-highlight-prelude-color:#69f2df;--code-highlight-prelude-val-color:#ff7733;--code-highlight-number-color:#b8cc52;--code-highlight-string-color:#b8cc52;--code-highlight-literal-color:#ff7733;--code-highlight-attribute-color:#e6e1cf;--code-highlight-self-color:#36a3d9;--code-highlight-macro-color:#a37acc;--code-highlight-question-mark-color:#ff9011;--code-highlight-comment-color:#788797;--code-highlight-doc-comment-color:#a1ac88;--src-line-numbers-span-color:#5c6773;--src-line-number-highlighted-background-color:rgba(255,236,164,0.06);--test-arrow-color:#788797;--test-arrow-background-color:rgba(57,175,215,0.09);--test-arrow-hover-color:#c5c5c5;--test-arrow-hover-background-color:rgba(57,175,215,0.368);--target-background-color:rgba(255,236,164,0.06);--target-border-color:rgba(255,180,76,0.85);--kbd-color:#c5c5c5;--kbd-background:#314559;--kbd-box-shadow-color:#5c6773;--rust-logo-filter:drop-shadow(1px 0 0px #fff) drop-shadow(0 1px 0 #fff) drop-shadow(-1px 0 0 #fff) drop-shadow(0 -1px 0 #fff);--crate-search-div-filter:invert(41%) sepia(12%) saturate(487%) hue-rotate(171deg) brightness(94%) contrast(94%);--crate-search-div-hover-filter:invert(98%) sepia(12%) saturate(81%) hue-rotate(343deg) brightness(113%) contrast(76%);--crate-search-hover-border:#e0e0e0;--src-sidebar-background-selected:#14191f;--src-sidebar-background-hover:#14191f;--table-alt-row-background-color:#191f26;--codeblock-link-background:#333;--scrape-example-toggle-line-background:#999;--scrape-example-toggle-line-hover-background:#c5c5c5;--scrape-example-code-line-highlight:#5b3b01;--scrape-example-code-line-highlight-focus:#7c4b0f;--scrape-example-help-border-color:#aaa;--scrape-example-help-color:#eee;--scrape-example-help-hover-border-color:#fff;--scrape-example-help-hover-color:#fff;--scrape-example-code-wrapper-background-start:rgba(15,20,25,1);--scrape-example-code-wrapper-background-end:rgba(15,20,25,0);}:root[data-theme="ayu"] h1,:root[data-theme="ayu"] h2,:root[data-theme="ayu"] h3,:root[data-theme="ayu"] h4,:where(:root[data-theme="ayu"]) h1 a,:root[data-theme="ayu"] .sidebar h2 a,:root[data-theme="ayu"] .sidebar h3 a,:root[data-theme="ayu"] #source-sidebar>.title{color:#fff;}:root[data-theme="ayu"] .docblock code{color:#ffb454;}:root[data-theme="ayu"] .docblock a>code{color:#39AFD7 !important;}:root[data-theme="ayu"] .code-header,:root[data-theme="ayu"] .docblock pre>code,:root[data-theme="ayu"] pre,:root[data-theme="ayu"] pre>code,:root[data-theme="ayu"] .item-info code,:root[data-theme="ayu"] .rustdoc.source .example-wrap{color:#e6e1cf;}:root[data-theme="ayu"] .sidebar .current,:root[data-theme="ayu"] .sidebar a:hover,:root[data-theme="ayu"] #src-sidebar div.files>a:hover,:root[data-theme="ayu"] details.dir-entry summary:hover,:root[data-theme="ayu"] #src-sidebar div.files>a:focus,:root[data-theme="ayu"] details.dir-entry summary:focus,:root[data-theme="ayu"] #src-sidebar div.files>a.selected{color:#ffb44c;}:root[data-theme="ayu"] .sidebar-elems .location{color:#ff7733;}:root[data-theme="ayu"] .src-line-numbers .line-highlighted{color:#708090;padding-right:7px;border-right:1px solid #ffb44c;}:root[data-theme="ayu"] .search-results a:hover,:root[data-theme="ayu"] .search-results a:focus{color:#fff !important;background-color:#3c3c3c;}:root[data-theme="ayu"] .search-results a{color:#0096cf;}:root[data-theme="ayu"] .search-results a div.desc{color:#c5c5c5;}:root[data-theme="ayu"] .result-name .primitive>i,:root[data-theme="ayu"] .result-name .keyword>i{color:#788797;}:root[data-theme="ayu"] #search-tabs>button.selected{border-bottom:1px solid #ffb44c !important;border-top:none;}:root[data-theme="ayu"] #search-tabs>button:not(.selected){border:none;background-color:transparent !important;}:root[data-theme="ayu"] #search-tabs>button:hover{border-bottom:1px solid rgba(242,151,24,0.3);}:root[data-theme="ayu"] #settings-menu>a img{filter:invert(100);} \ No newline at end of file diff --git a/ch5/static.files/scrape-examples-ef1e698c1d417c0c.js b/ch5/static.files/scrape-examples-ef1e698c1d417c0c.js new file mode 100644 index 00000000..ba830e37 --- /dev/null +++ b/ch5/static.files/scrape-examples-ef1e698c1d417c0c.js @@ -0,0 +1 @@ +"use strict";(function(){const DEFAULT_MAX_LINES=5;const HIDDEN_MAX_LINES=10;function scrollToLoc(elt,loc,isHidden){const lines=elt.querySelector(".src-line-numbers");let scrollOffset;const maxLines=isHidden?HIDDEN_MAX_LINES:DEFAULT_MAX_LINES;if(loc[1]-loc[0]>maxLines){const line=Math.max(0,loc[0]-1);scrollOffset=lines.children[line].offsetTop}else{const wrapper=elt.querySelector(".code-wrapper");const halfHeight=wrapper.offsetHeight/2;const offsetTop=lines.children[loc[0]].offsetTop;const lastLine=lines.children[loc[1]];const offsetBot=lastLine.offsetTop+lastLine.offsetHeight;const offsetMid=(offsetTop+offsetBot)/2;scrollOffset=offsetMid-halfHeight}lines.scrollTo(0,scrollOffset);elt.querySelector(".rust").scrollTo(0,scrollOffset)}function updateScrapedExample(example,isHidden){const locs=JSON.parse(example.attributes.getNamedItem("data-locs").textContent);let locIndex=0;const highlights=Array.prototype.slice.call(example.querySelectorAll(".highlight"));const link=example.querySelector(".scraped-example-title a");if(locs.length>1){const onChangeLoc=changeIndex=>{removeClass(highlights[locIndex],"focus");changeIndex();scrollToLoc(example,locs[locIndex][0],isHidden);addClass(highlights[locIndex],"focus");const url=locs[locIndex][1];const title=locs[locIndex][2];link.href=url;link.innerHTML=title};example.querySelector(".prev").addEventListener("click",()=>{onChangeLoc(()=>{locIndex=(locIndex-1+locs.length)%locs.length})});example.querySelector(".next").addEventListener("click",()=>{onChangeLoc(()=>{locIndex=(locIndex+1)%locs.length})})}const expandButton=example.querySelector(".expand");if(expandButton){expandButton.addEventListener("click",()=>{if(hasClass(example,"expanded")){removeClass(example,"expanded");scrollToLoc(example,locs[0][0],isHidden)}else{addClass(example,"expanded")}})}scrollToLoc(example,locs[0][0],isHidden)}const firstExamples=document.querySelectorAll(".scraped-example-list > .scraped-example");onEachLazy(firstExamples,el=>updateScrapedExample(el,false));onEachLazy(document.querySelectorAll(".more-examples-toggle"),toggle=>{onEachLazy(toggle.querySelectorAll(".toggle-line, .hide-more"),button=>{button.addEventListener("click",()=>{toggle.open=false})});const moreExamples=toggle.querySelectorAll(".scraped-example");toggle.querySelector("summary").addEventListener("click",()=>{setTimeout(()=>{onEachLazy(moreExamples,el=>updateScrapedExample(el,true))})},{once:true})})})() \ No newline at end of file diff --git a/ch5/static.files/search-5f5ec5419eadd0c9.js b/ch5/static.files/search-5f5ec5419eadd0c9.js new file mode 100644 index 00000000..e25c1820 --- /dev/null +++ b/ch5/static.files/search-5f5ec5419eadd0c9.js @@ -0,0 +1,5 @@ +"use strict";if(!Array.prototype.toSpliced){Array.prototype.toSpliced=function(){const me=this.slice();Array.prototype.splice.apply(me,arguments);return me}}(function(){const itemTypes=["mod","externcrate","import","struct","enum","fn","type","static","trait","impl","tymethod","method","structfield","variant","macro","primitive","associatedtype","constant","associatedconstant","union","foreigntype","keyword","existential","attr","derive","traitalias","generic",];const longItemTypes=["module","extern crate","re-export","struct","enum","function","type alias","static","trait","","trait method","method","struct field","enum variant","macro","primitive type","assoc type","constant","assoc const","union","foreign type","keyword","existential type","attribute macro","derive macro","trait alias",];const TY_PRIMITIVE=itemTypes.indexOf("primitive");const TY_KEYWORD=itemTypes.indexOf("keyword");const TY_GENERIC=itemTypes.indexOf("generic");const ROOT_PATH=typeof window!=="undefined"?window.rootPath:"../";function hasOwnPropertyRustdoc(obj,property){return Object.prototype.hasOwnProperty.call(obj,property)}function printTab(nb){let iter=0;let foundCurrentTab=false;let foundCurrentResultSet=false;onEachLazy(document.getElementById("search-tabs").childNodes,elem=>{if(nb===iter){addClass(elem,"selected");foundCurrentTab=true}else{removeClass(elem,"selected")}iter+=1});const isTypeSearch=(nb>0||iter===1);iter=0;onEachLazy(document.getElementById("results").childNodes,elem=>{if(nb===iter){addClass(elem,"active");foundCurrentResultSet=true}else{removeClass(elem,"active")}iter+=1});if(foundCurrentTab&&foundCurrentResultSet){searchState.currentTab=nb;const correctionsElem=document.getElementsByClassName("search-corrections");if(isTypeSearch){removeClass(correctionsElem[0],"hidden")}else{addClass(correctionsElem[0],"hidden")}}else if(nb!==0){printTab(0)}}const editDistanceState={current:[],prev:[],prevPrev:[],calculate:function calculate(a,b,limit){if(a.lengthlimit){return limit+1}while(b.length>0&&b[0]===a[0]){a=a.substring(1);b=b.substring(1)}while(b.length>0&&b[b.length-1]===a[a.length-1]){a=a.substring(0,a.length-1);b=b.substring(0,b.length-1)}if(b.length===0){return minDist}const aLength=a.length;const bLength=b.length;for(let i=0;i<=bLength;++i){this.current[i]=0;this.prev[i]=i;this.prevPrev[i]=Number.MAX_VALUE}for(let i=1;i<=aLength;++i){this.current[0]=i;const aIdx=i-1;for(let j=1;j<=bLength;++j){const bIdx=j-1;const substitutionCost=a[aIdx]===b[bIdx]?0:1;this.current[j]=Math.min(this.prev[j]+1,this.current[j-1]+1,this.prev[j-1]+substitutionCost);if((i>1)&&(j>1)&&(a[aIdx]===b[bIdx-1])&&(a[aIdx-1]===b[bIdx])){this.current[j]=Math.min(this.current[j],this.prevPrev[j-2]+1)}}const prevPrevTmp=this.prevPrev;this.prevPrev=this.prev;this.prev=this.current;this.current=prevPrevTmp}const distance=this.prev[bLength];return distance<=limit?distance:(limit+1)},};function editDistance(a,b,limit){return editDistanceState.calculate(a,b,limit)}function initSearch(rawSearchIndex){const MAX_RESULTS=200;const NO_TYPE_FILTER=-1;let searchIndex;let currentResults;let typeNameIdMap;const ALIASES=new Map();let typeNameIdOfArray;let typeNameIdOfSlice;let typeNameIdOfArrayOrSlice;function buildTypeMapIndex(name){if(name===""||name===null){return null}if(typeNameIdMap.has(name)){return typeNameIdMap.get(name)}else{const id=typeNameIdMap.size;typeNameIdMap.set(name,id);return id}}function isWhitespace(c){return" \t\n\r".indexOf(c)!==-1}function isSpecialStartCharacter(c){return"<\"".indexOf(c)!==-1}function isEndCharacter(c){return",>-]".indexOf(c)!==-1}function isStopCharacter(c){return isEndCharacter(c)}function isErrorCharacter(c){return"()".indexOf(c)!==-1}function itemTypeFromName(typename){const index=itemTypes.findIndex(i=>i===typename);if(index<0){throw["Unknown type filter ",typename]}return index}function getStringElem(query,parserState,isInGenerics){if(isInGenerics){throw["Unexpected ","\""," in generics"]}else if(query.literalSearch){throw["Cannot have more than one literal search element"]}else if(parserState.totalElems-parserState.genericsElems>0){throw["Cannot use literal search when there is more than one element"]}parserState.pos+=1;const start=parserState.pos;const end=getIdentEndPosition(parserState);if(parserState.pos>=parserState.length){throw["Unclosed ","\""]}else if(parserState.userQuery[end]!=="\""){throw["Unexpected ",parserState.userQuery[end]," in a string element"]}else if(start===end){throw["Cannot have empty string element"]}parserState.pos+=1;query.literalSearch=true}function isPathStart(parserState){return parserState.userQuery.slice(parserState.pos,parserState.pos+2)==="::"}function isReturnArrow(parserState){return parserState.userQuery.slice(parserState.pos,parserState.pos+2)==="->"}function isIdentCharacter(c){return(c==="_"||(c>="0"&&c<="9")||(c>="a"&&c<="z")||(c>="A"&&c<="Z"))}function isSeparatorCharacter(c){return c===","}function isPathSeparator(c){return c===":"||isWhitespace(c)}function prevIs(parserState,lookingFor){let pos=parserState.pos;while(pos>0){const c=parserState.userQuery[pos-1];if(c===lookingFor){return true}else if(!isWhitespace(c)){break}pos-=1}return false}function isLastElemGeneric(elems,parserState){return(elems.length>0&&elems[elems.length-1].generics.length>0)||prevIs(parserState,">")}function skipWhitespace(parserState){while(parserState.pos0){throw["Cannot have more than one element if you use quotes"]}const typeFilter=parserState.typeFilter;parserState.typeFilter=null;if(name==="!"){if(typeFilter!==null&&typeFilter!=="primitive"){throw["Invalid search type: primitive never type ","!"," and ",typeFilter," both specified",]}if(generics.length!==0){throw["Never type ","!"," does not accept generic parameters",]}return{name:"never",id:null,fullPath:["never"],pathWithoutLast:[],pathLast:"never",generics:[],typeFilter:"primitive",}}if(path.startsWith("::")){throw["Paths cannot start with ","::"]}else if(path.endsWith("::")){throw["Paths cannot end with ","::"]}else if(path.includes("::::")){throw["Unexpected ","::::"]}else if(path.includes(" ::")){throw["Unexpected "," ::"]}else if(path.includes(":: ")){throw["Unexpected ",":: "]}const pathSegments=path.split(/::|\s+/);if(pathSegments.length===0||(pathSegments.length===1&&pathSegments[0]==="")){if(generics.length>0||prevIs(parserState,">")){throw["Found generics without a path"]}else{throw["Unexpected ",parserState.userQuery[parserState.pos]]}}for(const[i,pathSegment]of pathSegments.entries()){if(pathSegment==="!"){if(i!==0){throw["Never type ","!"," is not associated item"]}pathSegments[i]="never"}}parserState.totalElems+=1;if(isInGenerics){parserState.genericsElems+=1}return{name:name.trim(),id:null,fullPath:pathSegments,pathWithoutLast:pathSegments.slice(0,pathSegments.length-1),pathLast:pathSegments[pathSegments.length-1],generics:generics,typeFilter,}}function getIdentEndPosition(parserState){const start=parserState.pos;let end=parserState.pos;let foundExclamation=-1;while(parserState.pos=end){throw["Found generics without a path"]}parserState.pos+=1;getItemsBefore(query,parserState,generics,">")}if(isStringElem){skipWhitespace(parserState)}if(start>=end&&generics.length===0){return}elems.push(createQueryElement(query,parserState,parserState.userQuery.slice(start,end),generics,isInGenerics))}}function getItemsBefore(query,parserState,elems,endChar){let foundStopChar=true;let start=parserState.pos;const oldTypeFilter=parserState.typeFilter;parserState.typeFilter=null;let extra="";if(endChar===">"){extra="<"}else if(endChar==="]"){extra="["}else if(endChar===""){extra="->"}else{extra=endChar}while(parserState.pos"]}else if(prevIs(parserState,"\"")){throw["Cannot have more than one element if you use quotes"]}if(endChar!==""){throw["Expected ",","," or ",endChar,...extra,", found ",c,]}throw["Expected ",",",...extra,", found ",c,]}const posBefore=parserState.pos;start=parserState.pos;getNextElem(query,parserState,elems,endChar!=="");if(endChar!==""&&parserState.pos>=parserState.length){throw["Unclosed ",extra]}if(posBefore===parserState.pos){parserState.pos+=1}foundStopChar=false}if(parserState.pos>=parserState.length&&endChar!==""){throw["Unclosed ",extra]}parserState.pos+=1;parserState.typeFilter=oldTypeFilter}function checkExtraTypeFilterCharacters(start,parserState){const query=parserState.userQuery.slice(start,parserState.pos).trim();for(const c in query){if(!isIdentCharacter(query[c])){throw["Unexpected ",query[c]," in type filter (before ",":",")",]}}}function parseInput(query,parserState){let foundStopChar=true;let start=parserState.pos;while(parserState.pos"){if(isReturnArrow(parserState)){break}throw["Unexpected ",c," (did you mean ","->","?)"]}throw["Unexpected ",c]}else if(c===":"&&!isPathStart(parserState)){if(parserState.typeFilter!==null){throw["Unexpected ",":"," (expected path after type filter ",parserState.typeFilter+":",")",]}else if(query.elems.length===0){throw["Expected type filter before ",":"]}else if(query.literalSearch){throw["Cannot use quotes on type filter"]}const typeFilterElem=query.elems.pop();checkExtraTypeFilterCharacters(start,parserState);parserState.typeFilter=typeFilterElem.name;parserState.pos+=1;parserState.totalElems-=1;query.literalSearch=false;foundStopChar=true;continue}else if(isWhitespace(c)){skipWhitespace(parserState);continue}if(!foundStopChar){let extra="";if(isLastElemGeneric(query.elems,parserState)){extra=[" after ",">"]}else if(prevIs(parserState,"\"")){throw["Cannot have more than one element if you use quotes"]}if(parserState.typeFilter!==null){throw["Expected ",","," or ","->",...extra,", found ",c,]}throw["Expected ",",",", ",":"," or ","->",...extra,", found ",c,]}const before=query.elems.length;start=parserState.pos;getNextElem(query,parserState,query.elems,false);if(query.elems.length===before){parserState.pos+=1}foundStopChar=false}if(parserState.typeFilter!==null){throw["Unexpected ",":"," (expected path after type filter ",parserState.typeFilter+":",")",]}while(parserState.pos"]}break}else{parserState.pos+=1}}}function newParsedQuery(userQuery){return{original:userQuery,userQuery:userQuery.toLowerCase(),elems:[],returned:[],foundElems:0,totalElems:0,literalSearch:false,error:null,correction:null,proposeCorrectionFrom:null,proposeCorrectionTo:null,}}function buildUrl(search,filterCrates){let extra="?search="+encodeURIComponent(search);if(filterCrates!==null){extra+="&filter-crate="+encodeURIComponent(filterCrates)}return getNakedUrl()+extra+window.location.hash}function getFilterCrates(){const elem=document.getElementById("crate-search");if(elem&&elem.value!=="all crates"&&hasOwnPropertyRustdoc(rawSearchIndex,elem.value)){return elem.value}return null}function parseQuery(userQuery){function convertTypeFilterOnElem(elem){if(elem.typeFilter!==null){let typeFilter=elem.typeFilter;if(typeFilter==="const"){typeFilter="constant"}elem.typeFilter=itemTypeFromName(typeFilter)}else{elem.typeFilter=NO_TYPE_FILTER}for(const elem2 of elem.generics){convertTypeFilterOnElem(elem2)}}userQuery=userQuery.trim();const parserState={length:userQuery.length,pos:0,totalElems:0,genericsElems:0,typeFilter:null,userQuery:userQuery.toLowerCase(),};let query=newParsedQuery(userQuery);try{parseInput(query,parserState);for(const elem of query.elems){convertTypeFilterOnElem(elem)}for(const elem of query.returned){convertTypeFilterOnElem(elem)}}catch(err){query=newParsedQuery(userQuery);query.error=err;return query}if(!query.literalSearch){query.literalSearch=parserState.totalElems>1}query.foundElems=query.elems.length+query.returned.length;query.totalElems=parserState.totalElems;return query}function createQueryResults(results_in_args,results_returned,results_others,parsedQuery){return{"in_args":results_in_args,"returned":results_returned,"others":results_others,"query":parsedQuery,}}function execQuery(parsedQuery,searchWords,filterCrates,currentCrate){const results_others=new Map(),results_in_args=new Map(),results_returned=new Map();function transformResults(results){const duplicates=new Set();const out=[];for(const result of results){if(result.id!==-1){const obj=searchIndex[result.id];obj.dist=result.dist;const res=buildHrefAndPath(obj);obj.displayPath=pathSplitter(res[0]);obj.fullPath=obj.displayPath+obj.name;obj.fullPath+="|"+obj.ty;if(duplicates.has(obj.fullPath)){continue}duplicates.add(obj.fullPath);obj.href=res[1];out.push(obj);if(out.length>=MAX_RESULTS){break}}}return out}function sortResults(results,isType,preferredCrate){if(results.size===0){return[]}const userQuery=parsedQuery.userQuery;const result_list=[];for(const result of results.values()){result.word=searchWords[result.id];result.item=searchIndex[result.id]||{};result_list.push(result)}result_list.sort((aaa,bbb)=>{let a,b;a=(aaa.word!==userQuery);b=(bbb.word!==userQuery);if(a!==b){return a-b}a=(aaa.index<0);b=(bbb.index<0);if(a!==b){return a-b}a=aaa.path_dist;b=bbb.path_dist;if(a!==b){return a-b}a=aaa.index;b=bbb.index;if(a!==b){return a-b}a=(aaa.dist);b=(bbb.dist);if(a!==b){return a-b}a=aaa.item.deprecated;b=bbb.item.deprecated;if(a!==b){return a-b}a=(aaa.item.crate!==preferredCrate);b=(bbb.item.crate!==preferredCrate);if(a!==b){return a-b}a=aaa.word.length;b=bbb.word.length;if(a!==b){return a-b}a=aaa.word;b=bbb.word;if(a!==b){return(a>b?+1:-1)}if((aaa.item.ty===TY_PRIMITIVE&&bbb.item.ty!==TY_KEYWORD)||(aaa.item.ty===TY_KEYWORD&&bbb.item.ty!==TY_PRIMITIVE)){return-1}if((bbb.item.ty===TY_PRIMITIVE&&aaa.item.ty!==TY_PRIMITIVE)||(bbb.item.ty===TY_KEYWORD&&aaa.item.ty!==TY_KEYWORD)){return 1}a=(aaa.item.desc==="");b=(bbb.item.desc==="");if(a!==b){return a-b}a=aaa.item.ty;b=bbb.item.ty;if(a!==b){return a-b}a=aaa.item.path;b=bbb.item.path;if(a!==b){return(a>b?+1:-1)}return 0});let nameSplit=null;if(parsedQuery.elems.length===1){const hasPath=typeof parsedQuery.elems[0].path==="undefined";nameSplit=hasPath?null:parsedQuery.elems[0].path}for(const result of result_list){if(result.dontValidate){continue}const name=result.item.name.toLowerCase(),path=result.item.path.toLowerCase(),parent=result.item.parent;if(!isType&&!validateResult(name,path,nameSplit,parent)){result.id=-1}}return transformResults(result_list)}function checkGenerics(fnType,queryElem,whereClause,mgensInout){return unifyFunctionTypes(fnType.generics,queryElem.generics,whereClause,mgensInout,mgens=>{if(mgensInout){for(const[fid,qid]of mgens.entries()){mgensInout.set(fid,qid)}}return true})}function unifyFunctionTypes(fnTypesIn,queryElems,whereClause,mgensIn,solutionCb){let mgens=new Map(mgensIn);if(queryElems.length===0){return!solutionCb||solutionCb(mgens)}if(!fnTypesIn||fnTypesIn.length===0){return false}const ql=queryElems.length;let fl=fnTypesIn.length;let fnTypes=fnTypesIn.slice();const backtracking=[];let i=0;let j=0;const backtrack=()=>{while(backtracking.length!==0){const{fnTypesScratch,mgensScratch,queryElemsOffset,fnTypesOffset,unbox,}=backtracking.pop();mgens=new Map(mgensScratch);const fnType=fnTypesScratch[fnTypesOffset];const queryElem=queryElems[queryElemsOffset];if(unbox){if(fnType.id<0){if(mgens.has(fnType.id)&&mgens.get(fnType.id)!==0){continue}mgens.set(fnType.id,0)}const generics=fnType.id<0?whereClause[(-fnType.id)-1]:fnType.generics;fnTypes=fnTypesScratch.toSpliced(fnTypesOffset,1,...generics);fl=fnTypes.length;i=queryElemsOffset-1}else{if(fnType.id<0){if(mgens.has(fnType.id)&&mgens.get(fnType.id)!==queryElem.id){continue}mgens.set(fnType.id,queryElem.id)}fnTypes=fnTypesScratch.slice();fl=fnTypes.length;const tmp=fnTypes[queryElemsOffset];fnTypes[queryElemsOffset]=fnTypes[fnTypesOffset];fnTypes[fnTypesOffset]=tmp;i=queryElemsOffset}return true}return false};for(i=0;i!==ql;++i){const queryElem=queryElems[i];const matchCandidates=[];let fnTypesScratch=null;let mgensScratch=null;for(j=i;j!==fl;++j){const fnType=fnTypes[j];if(unifyFunctionTypeIsMatchCandidate(fnType,queryElem,whereClause,mgens)){if(!fnTypesScratch){fnTypesScratch=fnTypes.slice()}unifyFunctionTypes(fnType.generics,queryElem.generics,whereClause,mgens,mgensScratch=>{matchCandidates.push({fnTypesScratch,mgensScratch,queryElemsOffset:i,fnTypesOffset:j,unbox:false,});return false})}if(unifyFunctionTypeIsUnboxCandidate(fnType,queryElem,whereClause,mgens)){if(!fnTypesScratch){fnTypesScratch=fnTypes.slice()}if(!mgensScratch){mgensScratch=new Map(mgens)}backtracking.push({fnTypesScratch,mgensScratch,queryElemsOffset:i,fnTypesOffset:j,unbox:true,})}}if(matchCandidates.length===0){if(backtrack()){continue}else{return false}}const{fnTypesOffset:candidate,mgensScratch:mgensNew}=matchCandidates.pop();if(fnTypes[candidate].id<0&&queryElems[i].id<0){mgens.set(fnTypes[candidate].id,queryElems[i].id)}for(const[fid,qid]of mgensNew){mgens.set(fid,qid)}const tmp=fnTypes[candidate];fnTypes[candidate]=fnTypes[i];fnTypes[i]=tmp;for(const otherCandidate of matchCandidates){backtracking.push(otherCandidate)}while(i===(ql-1)&&solutionCb&&!solutionCb(mgens)){if(!backtrack()){return false}}}return true}function unifyFunctionTypeIsMatchCandidate(fnType,queryElem,whereClause,mgens){if(!typePassesFilter(queryElem.typeFilter,fnType.ty)){return false}if(fnType.id<0&&queryElem.id<0){if(mgens.has(fnType.id)&&mgens.get(fnType.id)!==queryElem.id){return false}for(const[fid,qid]of mgens.entries()){if(fnType.id!==fid&&queryElem.id===qid){return false}if(fnType.id===fid&&queryElem.id!==qid){return false}}}else{if(queryElem.id===typeNameIdOfArrayOrSlice&&(fnType.id===typeNameIdOfSlice||fnType.id===typeNameIdOfArray)){}else if(fnType.id!==queryElem.id){return false}if(fnType.generics.length===0&&queryElem.generics.length!==0){return false}const queryElemPathLength=queryElem.pathWithoutLast.length;if(queryElemPathLength>0){const fnTypePath=fnType.path!==undefined&&fnType.path!==null?fnType.path.split("::"):[];if(queryElemPathLength>fnTypePath.length){return false}let i=0;for(const path of fnTypePath){if(path===queryElem.pathWithoutLast[i]){i+=1;if(i>=queryElemPathLength){break}}}if(i=0){if(!whereClause){return false}if(mgens.has(fnType.id)&&mgens.get(fnType.id)!==0){return false}return checkIfInList(whereClause[(-fnType.id)-1],queryElem,whereClause)}else if(fnType.generics&&fnType.generics.length>0){return checkIfInList(fnType.generics,queryElem,whereClause)}return false}function checkIfInList(list,elem,whereClause){for(const entry of list){if(checkType(entry,elem,whereClause)){return true}}return false}function checkType(row,elem,whereClause){if(row.id===null){return row.generics.length>0?checkIfInList(row.generics,elem,whereClause):false}if(row.id<0&&elem.id>=0){const gid=(-row.id)-1;return checkIfInList(whereClause[gid],elem,whereClause)}if(row.id<0&&elem.id<0){return true}const matchesExact=row.id===elem.id;const matchesArrayOrSlice=elem.id===typeNameIdOfArrayOrSlice&&(row.id===typeNameIdOfSlice||row.id===typeNameIdOfArray);if((matchesExact||matchesArrayOrSlice)&&typePassesFilter(elem.typeFilter,row.ty)){if(elem.generics.length>0){return checkGenerics(row,elem,whereClause,new Map())}return true}return checkIfInList(row.generics,elem,whereClause)}function checkPath(contains,ty,maxEditDistance){if(contains.length===0){return 0}let ret_dist=maxEditDistance+1;const path=ty.path.split("::");if(ty.parent&&ty.parent.name){path.push(ty.parent.name.toLowerCase())}const length=path.length;const clength=contains.length;if(clength>length){return maxEditDistance+1}for(let i=0;ilength){break}let dist_total=0;let aborted=false;for(let x=0;xmaxEditDistance){aborted=true;break}dist_total+=dist}if(!aborted){ret_dist=Math.min(ret_dist,Math.round(dist_total/clength))}}return ret_dist}function typePassesFilter(filter,type){if(filter<=NO_TYPE_FILTER||filter===type)return true;const name=itemTypes[type];switch(itemTypes[filter]){case"constant":return name==="associatedconstant";case"fn":return name==="method"||name==="tymethod";case"type":return name==="primitive"||name==="associatedtype";case"trait":return name==="traitalias"}return false}function createAliasFromItem(item){return{crate:item.crate,name:item.name,path:item.path,desc:item.desc,ty:item.ty,parent:item.parent,type:item.type,is_alias:true,deprecated:item.deprecated,}}function handleAliases(ret,query,filterCrates,currentCrate){const lowerQuery=query.toLowerCase();const aliases=[];const crateAliases=[];if(filterCrates!==null){if(ALIASES.has(filterCrates)&&ALIASES.get(filterCrates).has(lowerQuery)){const query_aliases=ALIASES.get(filterCrates).get(lowerQuery);for(const alias of query_aliases){aliases.push(createAliasFromItem(searchIndex[alias]))}}}else{for(const[crate,crateAliasesIndex]of ALIASES){if(crateAliasesIndex.has(lowerQuery)){const pushTo=crate===currentCrate?crateAliases:aliases;const query_aliases=crateAliasesIndex.get(lowerQuery);for(const alias of query_aliases){pushTo.push(createAliasFromItem(searchIndex[alias]))}}}}const sortFunc=(aaa,bbb)=>{if(aaa.path{alias.alias=query;const res=buildHrefAndPath(alias);alias.displayPath=pathSplitter(res[0]);alias.fullPath=alias.displayPath+alias.name;alias.href=res[1];ret.others.unshift(alias);if(ret.others.length>MAX_RESULTS){ret.others.pop()}};aliases.forEach(pushFunc);crateAliases.forEach(pushFunc)}function addIntoResults(results,fullId,id,index,dist,path_dist,maxEditDistance){const inBounds=dist<=maxEditDistance||index!==-1;if(dist===0||(!parsedQuery.literalSearch&&inBounds)){if(results.has(fullId)){const result=results.get(fullId);if(result.dontValidate||result.dist<=dist){return}}results.set(fullId,{id:id,index:index,dontValidate:parsedQuery.literalSearch,dist:dist,path_dist:path_dist,})}}function handleSingleArg(row,pos,elem,results_others,results_in_args,results_returned,maxEditDistance){if(!row||(filterCrates!==null&&row.crate!==filterCrates)){return}let index=-1,path_dist=0;const fullId=row.id;const searchWord=searchWords[pos];const in_args=row.type&&row.type.inputs&&checkIfInList(row.type.inputs,elem,row.type.where_clause);if(in_args){addIntoResults(results_in_args,fullId,pos,-1,0,0,maxEditDistance)}const returned=row.type&&row.type.output&&checkIfInList(row.type.output,elem,row.type.where_clause);if(returned){addIntoResults(results_returned,fullId,pos,-1,0,0,maxEditDistance)}if(!typePassesFilter(elem.typeFilter,row.ty)){return}const row_index=row.normalizedName.indexOf(elem.pathLast);const word_index=searchWord.indexOf(elem.pathLast);if(row_index===-1){index=word_index}else if(word_index===-1){index=row_index}else if(word_index1){path_dist=checkPath(elem.pathWithoutLast,row,maxEditDistance);if(path_dist>maxEditDistance){return}}if(parsedQuery.literalSearch){if(searchWord===elem.name){addIntoResults(results_others,fullId,pos,index,0,path_dist)}return}const dist=editDistance(searchWord,elem.pathLast,maxEditDistance);if(index===-1&&dist+path_dist>maxEditDistance){return}addIntoResults(results_others,fullId,pos,index,dist,path_dist,maxEditDistance)}function handleArgs(row,pos,results){if(!row||(filterCrates!==null&&row.crate!==filterCrates)||!row.type){return}if(!unifyFunctionTypes(row.type.inputs,parsedQuery.elems,row.type.where_clause,null,mgens=>{return unifyFunctionTypes(row.type.output,parsedQuery.returned,row.type.where_clause,mgens)})){return}addIntoResults(results,row.id,pos,0,0,0,Number.MAX_VALUE)}function innerRunQuery(){let elem,i,nSearchWords,in_returned,row;let queryLen=0;for(const elem of parsedQuery.elems){queryLen+=elem.name.length}for(const elem of parsedQuery.returned){queryLen+=elem.name.length}const maxEditDistance=Math.floor(queryLen/3);const genericSymbols=new Map();function convertNameToId(elem){if(typeNameIdMap.has(elem.pathLast)){elem.id=typeNameIdMap.get(elem.pathLast)}else if(!parsedQuery.literalSearch){let match=null;let matchDist=maxEditDistance+1;let matchName="";for(const[name,id]of typeNameIdMap){const dist=editDistance(name,elem.pathLast,maxEditDistance);if(dist<=matchDist&&dist<=maxEditDistance){if(dist===matchDist&&matchName>name){continue}match=id;matchDist=dist;matchName=name}}if(match!==null){parsedQuery.correction=matchName}elem.id=match}if((elem.id===null&&parsedQuery.totalElems>1&&elem.typeFilter===-1&&elem.generics.length===0)||elem.typeFilter===TY_GENERIC){if(genericSymbols.has(elem.name)){elem.id=genericSymbols.get(elem.name)}else{elem.id=-(genericSymbols.size+1);genericSymbols.set(elem.name,elem.id)}if(elem.typeFilter===-1&&elem.name.length>=3){const maxPartDistance=Math.floor(elem.name.length/3);let matchDist=maxPartDistance+1;let matchName="";for(const name of typeNameIdMap.keys()){const dist=editDistance(name,elem.name,maxPartDistance);if(dist<=matchDist&&dist<=maxPartDistance){if(dist===matchDist&&matchName>name){continue}matchDist=dist;matchName=name}}if(matchName!==""){parsedQuery.proposeCorrectionFrom=elem.name;parsedQuery.proposeCorrectionTo=matchName}}elem.typeFilter=TY_GENERIC}if(elem.generics.length>0&&elem.typeFilter===TY_GENERIC){parsedQuery.error=["Generic type parameter ",elem.name," does not accept generic parameters",]}for(const elem2 of elem.generics){convertNameToId(elem2)}}for(const elem of parsedQuery.elems){convertNameToId(elem)}for(const elem of parsedQuery.returned){convertNameToId(elem)}if(parsedQuery.foundElems===1){if(parsedQuery.elems.length===1){elem=parsedQuery.elems[0];for(i=0,nSearchWords=searchWords.length;i0){for(i=0,nSearchWords=searchWords.length;i-1||path.indexOf(key)>-1||(parent!==undefined&&parent.name!==undefined&&parent.name.toLowerCase().indexOf(key)>-1)||editDistance(name,key,maxEditDistance)<=maxEditDistance)){return false}}return true}function nextTab(direction){const next=(searchState.currentTab+direction+3)%searchState.focusedByTab.length;searchState.focusedByTab[searchState.currentTab]=document.activeElement;printTab(next);focusSearchResult()}function focusSearchResult(){const target=searchState.focusedByTab[searchState.currentTab]||document.querySelectorAll(".search-results.active a").item(0)||document.querySelectorAll("#search-tabs button").item(searchState.currentTab);searchState.focusedByTab[searchState.currentTab]=null;if(target){target.focus()}}function buildHrefAndPath(item){let displayPath;let href;const type=itemTypes[item.ty];const name=item.name;let path=item.path;if(type==="mod"){displayPath=path+"::";href=ROOT_PATH+path.replace(/::/g,"/")+"/"+name+"/index.html"}else if(type==="import"){displayPath=item.path+"::";href=ROOT_PATH+item.path.replace(/::/g,"/")+"/index.html#reexport."+name}else if(type==="primitive"||type==="keyword"){displayPath="";href=ROOT_PATH+path.replace(/::/g,"/")+"/"+type+"."+name+".html"}else if(type==="externcrate"){displayPath="";href=ROOT_PATH+name+"/index.html"}else if(item.parent!==undefined){const myparent=item.parent;let anchor="#"+type+"."+name;const parentType=itemTypes[myparent.ty];let pageType=parentType;let pageName=myparent.name;if(parentType==="primitive"){displayPath=myparent.name+"::"}else if(type==="structfield"&&parentType==="variant"){const enumNameIdx=item.path.lastIndexOf("::");const enumName=item.path.substr(enumNameIdx+2);path=item.path.substr(0,enumNameIdx);displayPath=path+"::"+enumName+"::"+myparent.name+"::";anchor="#variant."+myparent.name+".field."+name;pageType="enum";pageName=enumName}else{displayPath=path+"::"+myparent.name+"::"}href=ROOT_PATH+path.replace(/::/g,"/")+"/"+pageType+"."+pageName+".html"+anchor}else{displayPath=item.path+"::";href=ROOT_PATH+item.path.replace(/::/g,"/")+"/"+type+"."+name+".html"}return[displayPath,href]}function pathSplitter(path){const tmp=""+path.replace(/::/g,"::");if(tmp.endsWith("")){return tmp.slice(0,tmp.length-6)}return tmp}function addTab(array,query,display){let extraClass="";if(display===true){extraClass=" active"}const output=document.createElement("div");let length=0;if(array.length>0){output.className="search-results "+extraClass;array.forEach(item=>{const name=item.name;const type=itemTypes[item.ty];const longType=longItemTypes[item.ty];const typeName=longType.length!==0?`${longType}`:"?";length+=1;const link=document.createElement("a");link.className="result-"+type;link.href=item.href;const resultName=document.createElement("div");resultName.className="result-name";resultName.insertAdjacentHTML("beforeend",`${typeName}`);link.appendChild(resultName);let alias=" ";if(item.is_alias){alias=`
    \ +${item.alias} - see \ +
    `}resultName.insertAdjacentHTML("beforeend",`
    ${alias}\ +${item.displayPath}${name}\ +
    `);const description=document.createElement("div");description.className="desc";description.insertAdjacentHTML("beforeend",item.desc);link.appendChild(description);output.appendChild(link)})}else if(query.error===null){output.className="search-failed"+extraClass;output.innerHTML="No results :(
    "+"Try on DuckDuckGo?

    "+"Or try looking in one of these:"}return[output,length]}function makeTabHeader(tabNb,text,nbElems){const fmtNbElems=nbElems<10?`\u{2007}(${nbElems})\u{2007}\u{2007}`:nbElems<100?`\u{2007}(${nbElems})\u{2007}`:`\u{2007}(${nbElems})`;if(searchState.currentTab===tabNb){return""}return""}function showResults(results,go_to_first,filterCrates){const search=searchState.outputElement();if(go_to_first||(results.others.length===1&&getSettingValue("go-to-only-result")==="true")){window.onunload=()=>{};searchState.removeQueryParameters();const elem=document.createElement("a");elem.href=results.others[0].href;removeClass(elem,"active");document.body.appendChild(elem);elem.click();return}if(results.query===undefined){results.query=parseQuery(searchState.input.value)}currentResults=results.query.userQuery;const ret_others=addTab(results.others,results.query,true);const ret_in_args=addTab(results.in_args,results.query,false);const ret_returned=addTab(results.returned,results.query,false);let currentTab=searchState.currentTab;if((currentTab===0&&ret_others[1]===0)||(currentTab===1&&ret_in_args[1]===0)||(currentTab===2&&ret_returned[1]===0)){if(ret_others[1]!==0){currentTab=0}else if(ret_in_args[1]!==0){currentTab=1}else if(ret_returned[1]!==0){currentTab=2}}let crates="";const crates_list=Object.keys(rawSearchIndex);if(crates_list.length>1){crates=" in 
    "}let output=`

    Results${crates}

    `;if(results.query.error!==null){const error=results.query.error;error.forEach((value,index)=>{value=value.split("<").join("<").split(">").join(">");if(index%2!==0){error[index]=`${value.replaceAll(" ", " ")}`}else{error[index]=value}});output+=`

    Query parser error: "${error.join("")}".

    `;output+="
    "+makeTabHeader(0,"In Names",ret_others[1])+"
    ";currentTab=0}else if(results.query.foundElems<=1&&results.query.returned.length===0){output+="
    "+makeTabHeader(0,"In Names",ret_others[1])+makeTabHeader(1,"In Parameters",ret_in_args[1])+makeTabHeader(2,"In Return Types",ret_returned[1])+"
    "}else{const signatureTabTitle=results.query.elems.length===0?"In Function Return Types":results.query.returned.length===0?"In Function Parameters":"In Function Signatures";output+="
    "+makeTabHeader(0,signatureTabTitle,ret_others[1])+"
    ";currentTab=0}if(results.query.correction!==null){const orig=results.query.returned.length>0?results.query.returned[0].name:results.query.elems[0].name;output+="

    "+`Type "${orig}" not found. `+"Showing results for closest type name "+`"${results.query.correction}" instead.

    `}if(results.query.proposeCorrectionFrom!==null){const orig=results.query.proposeCorrectionFrom;const targ=results.query.proposeCorrectionTo;output+="

    "+`Type "${orig}" not found and used as generic parameter. `+`Consider searching for "${targ}" instead.

    `}const resultsElem=document.createElement("div");resultsElem.id="results";resultsElem.appendChild(ret_others[0]);resultsElem.appendChild(ret_in_args[0]);resultsElem.appendChild(ret_returned[0]);search.innerHTML=output;const crateSearch=document.getElementById("crate-search");if(crateSearch){crateSearch.addEventListener("input",updateCrate)}search.appendChild(resultsElem);searchState.showResults(search);const elems=document.getElementById("search-tabs").childNodes;searchState.focusedByTab=[];let i=0;for(const elem of elems){const j=i;elem.onclick=()=>printTab(j);searchState.focusedByTab.push(null);i+=1}printTab(currentTab)}function updateSearchHistory(url){if(!browserSupportsHistoryApi()){return}const params=searchState.getQueryStringParams();if(!history.state&&!params.search){history.pushState(null,"",url)}else{history.replaceState(null,"",url)}}function search(e,forced){if(e){e.preventDefault()}const query=parseQuery(searchState.input.value.trim());let filterCrates=getFilterCrates();if(!forced&&query.userQuery===currentResults){if(query.userQuery.length>0){putBackSearch()}return}searchState.setLoadingSearch();const params=searchState.getQueryStringParams();if(filterCrates===null&¶ms["filter-crate"]!==undefined){filterCrates=params["filter-crate"]}searchState.title="Results for "+query.original+" - Rust";updateSearchHistory(buildUrl(query.original,filterCrates));showResults(execQuery(query,searchWords,filterCrates,window.currentCrate),params.go_to_first,filterCrates)}function buildItemSearchTypeAll(types,lowercasePaths){return types.map(type=>buildItemSearchType(type,lowercasePaths))}function buildItemSearchType(type,lowercasePaths){const PATH_INDEX_DATA=0;const GENERICS_DATA=1;let pathIndex,generics;if(typeof type==="number"){pathIndex=type;generics=[]}else{pathIndex=type[PATH_INDEX_DATA];generics=buildItemSearchTypeAll(type[GENERICS_DATA],lowercasePaths)}if(pathIndex<0){return{id:pathIndex,ty:TY_GENERIC,path:null,generics,}}if(pathIndex===0){return{id:null,ty:null,path:null,generics,}}const item=lowercasePaths[pathIndex-1];return{id:buildTypeMapIndex(item.name),ty:item.ty,path:item.path,generics,}}function buildFunctionSearchType(functionSearchType,lowercasePaths){const INPUTS_DATA=0;const OUTPUT_DATA=1;if(functionSearchType===0){return null}let inputs,output;if(typeof functionSearchType[INPUTS_DATA]==="number"){inputs=[buildItemSearchType(functionSearchType[INPUTS_DATA],lowercasePaths)]}else{inputs=buildItemSearchTypeAll(functionSearchType[INPUTS_DATA],lowercasePaths)}if(functionSearchType.length>1){if(typeof functionSearchType[OUTPUT_DATA]==="number"){output=[buildItemSearchType(functionSearchType[OUTPUT_DATA],lowercasePaths)]}else{output=buildItemSearchTypeAll(functionSearchType[OUTPUT_DATA],lowercasePaths)}}else{output=[]}const where_clause=[];const l=functionSearchType.length;for(let i=2;i2){path=itemPaths.has(elem[2])?itemPaths.get(elem[2]):lastPath;lastPath=path}lowercasePaths.push({ty:ty,name:name.toLowerCase(),path:path});paths[i]={ty:ty,name:name,path:path}}lastPath="";len=itemTypes.length;for(let i=0;i0?paths[itemParentIdxs[i]-1]:undefined,type:buildFunctionSearchType(itemFunctionSearchTypes[i],lowercasePaths),id:id,normalizedName:word.indexOf("_")===-1?word:word.replace(/_/g,""),deprecated:deprecatedItems.has(i),};id+=1;searchIndex.push(row);lastPath=row.path;crateSize+=1}if(aliases){const currentCrateAliases=new Map();ALIASES.set(crate,currentCrateAliases);for(const alias_name in aliases){if(!hasOwnPropertyRustdoc(aliases,alias_name)){continue}let currentNameAliases;if(currentCrateAliases.has(alias_name)){currentNameAliases=currentCrateAliases.get(alias_name)}else{currentNameAliases=[];currentCrateAliases.set(alias_name,currentNameAliases)}for(const local_alias of aliases[alias_name]){currentNameAliases.push(local_alias+currentIndex)}}}currentIndex+=crateSize}return searchWords}function onSearchSubmit(e){e.preventDefault();searchState.clearInputTimeout();search()}function putBackSearch(){const search_input=searchState.input;if(!searchState.input){return}if(search_input.value!==""&&!searchState.isDisplayed()){searchState.showResults();if(browserSupportsHistoryApi()){history.replaceState(null,"",buildUrl(search_input.value,getFilterCrates()))}document.title=searchState.title}}function registerSearchEvents(){const params=searchState.getQueryStringParams();if(searchState.input.value===""){searchState.input.value=params.search||""}const searchAfter500ms=()=>{searchState.clearInputTimeout();if(searchState.input.value.length===0){searchState.hideResults()}else{searchState.timeout=setTimeout(search,500)}};searchState.input.onkeyup=searchAfter500ms;searchState.input.oninput=searchAfter500ms;document.getElementsByClassName("search-form")[0].onsubmit=onSearchSubmit;searchState.input.onchange=e=>{if(e.target!==document.activeElement){return}searchState.clearInputTimeout();setTimeout(search,0)};searchState.input.onpaste=searchState.input.onchange;searchState.outputElement().addEventListener("keydown",e=>{if(e.altKey||e.ctrlKey||e.shiftKey||e.metaKey){return}if(e.which===38){const previous=document.activeElement.previousElementSibling;if(previous){previous.focus()}else{searchState.focus()}e.preventDefault()}else if(e.which===40){const next=document.activeElement.nextElementSibling;if(next){next.focus()}const rect=document.activeElement.getBoundingClientRect();if(window.innerHeight-rect.bottom{if(e.which===40){focusSearchResult();e.preventDefault()}});searchState.input.addEventListener("focus",()=>{putBackSearch()});searchState.input.addEventListener("blur",()=>{searchState.input.placeholder=searchState.input.origPlaceholder});if(browserSupportsHistoryApi()){const previousTitle=document.title;window.addEventListener("popstate",e=>{const params=searchState.getQueryStringParams();document.title=previousTitle;currentResults=null;if(params.search&¶ms.search.length>0){searchState.input.value=params.search;search(e)}else{searchState.input.value="";searchState.hideResults()}})}window.onpageshow=()=>{const qSearch=searchState.getQueryStringParams().search;if(searchState.input.value===""&&qSearch){searchState.input.value=qSearch}search()}}function updateCrate(ev){if(ev.target.value==="all crates"){const query=searchState.input.value.trim();updateSearchHistory(buildUrl(query,null))}currentResults=null;search(undefined,true)}const searchWords=buildIndex(rawSearchIndex);if(typeof window!=="undefined"){registerSearchEvents();if(window.searchState.getQueryStringParams().search){search()}}if(typeof exports!=="undefined"){exports.initSearch=initSearch;exports.execQuery=execQuery;exports.parseQuery=parseQuery}return searchWords}if(typeof window!=="undefined"){window.initSearch=initSearch;if(window.searchIndex!==undefined){initSearch(window.searchIndex)}}else{initSearch({})}})() \ No newline at end of file diff --git a/ch5/static.files/settings-74424d7eec62a23e.js b/ch5/static.files/settings-74424d7eec62a23e.js new file mode 100644 index 00000000..3014f75c --- /dev/null +++ b/ch5/static.files/settings-74424d7eec62a23e.js @@ -0,0 +1,17 @@ +"use strict";(function(){const isSettingsPage=window.location.pathname.endsWith("/settings.html");function changeSetting(settingName,value){if(settingName==="theme"){const useSystem=value==="system preference"?"true":"false";updateLocalStorage("use-system-theme",useSystem)}updateLocalStorage(settingName,value);switch(settingName){case"theme":case"preferred-dark-theme":case"preferred-light-theme":updateTheme();updateLightAndDark();break;case"line-numbers":if(value===true){window.rustdoc_add_line_numbers_to_examples()}else{window.rustdoc_remove_line_numbers_from_examples()}break}}function showLightAndDark(){removeClass(document.getElementById("preferred-light-theme"),"hidden");removeClass(document.getElementById("preferred-dark-theme"),"hidden")}function hideLightAndDark(){addClass(document.getElementById("preferred-light-theme"),"hidden");addClass(document.getElementById("preferred-dark-theme"),"hidden")}function updateLightAndDark(){const useSystem=getSettingValue("use-system-theme");if(useSystem==="true"||(useSystem===null&&getSettingValue("theme")===null)){showLightAndDark()}else{hideLightAndDark()}}function setEvents(settingsElement){updateLightAndDark();onEachLazy(settingsElement.querySelectorAll("input[type=\"checkbox\"]"),toggle=>{const settingId=toggle.id;const settingValue=getSettingValue(settingId);if(settingValue!==null){toggle.checked=settingValue==="true"}toggle.onchange=()=>{changeSetting(toggle.id,toggle.checked)}});onEachLazy(settingsElement.querySelectorAll("input[type=\"radio\"]"),elem=>{const settingId=elem.name;let settingValue=getSettingValue(settingId);if(settingId==="theme"){const useSystem=getSettingValue("use-system-theme");if(useSystem==="true"||settingValue===null){settingValue=useSystem==="false"?"light":"system preference"}}if(settingValue!==null&&settingValue!=="null"){elem.checked=settingValue===elem.value}elem.addEventListener("change",ev=>{changeSetting(ev.target.name,ev.target.value)})})}function buildSettingsPageSections(settings){let output="";for(const setting of settings){const js_data_name=setting["js_name"];const setting_name=setting["name"];if(setting["options"]!==undefined){output+=`\ +
    +
    ${setting_name}
    +
    `;onEach(setting["options"],option=>{const checked=option===setting["default"]?" checked":"";const full=`${js_data_name}-${option.replace(/ /g,"-")}`;output+=`\ + `});output+=`\ +
    +
    `}else{const checked=setting["default"]===true?" checked":"";output+=`\ +
    \ + \ +
    `}}return output}function buildSettingsPage(){const theme_names=getVar("themes").split(",").filter(t=>t);theme_names.push("light","dark","ayu");const settings=[{"name":"Theme","js_name":"theme","default":"system preference","options":theme_names.concat("system preference"),},{"name":"Preferred light theme","js_name":"preferred-light-theme","default":"light","options":theme_names,},{"name":"Preferred dark theme","js_name":"preferred-dark-theme","default":"dark","options":theme_names,},{"name":"Auto-hide item contents for large items","js_name":"auto-hide-large-items","default":true,},{"name":"Auto-hide item methods' documentation","js_name":"auto-hide-method-docs","default":false,},{"name":"Auto-hide trait implementation documentation","js_name":"auto-hide-trait-implementations","default":false,},{"name":"Directly go to item in search if there is only one result","js_name":"go-to-only-result","default":false,},{"name":"Show line numbers on code examples","js_name":"line-numbers","default":false,},{"name":"Disable keyboard shortcuts","js_name":"disable-shortcuts","default":false,},];const elementKind=isSettingsPage?"section":"div";const innerHTML=`
    ${buildSettingsPageSections(settings)}
    `;const el=document.createElement(elementKind);el.id="settings";if(!isSettingsPage){el.className="popover"}el.innerHTML=innerHTML;if(isSettingsPage){document.getElementById(MAIN_ID).appendChild(el)}else{el.setAttribute("tabindex","-1");getSettingsButton().appendChild(el)}return el}const settingsMenu=buildSettingsPage();function displaySettings(){settingsMenu.style.display=""}function settingsBlurHandler(event){blurHandler(event,getSettingsButton(),window.hidePopoverMenus)}if(isSettingsPage){getSettingsButton().onclick=event=>{event.preventDefault()}}else{const settingsButton=getSettingsButton();const settingsMenu=document.getElementById("settings");settingsButton.onclick=event=>{if(elemIsInParent(event.target,settingsMenu)){return}event.preventDefault();const shouldDisplaySettings=settingsMenu.style.display==="none";window.hideAllModals();if(shouldDisplaySettings){displaySettings()}};settingsButton.onblur=settingsBlurHandler;settingsButton.querySelector("a").onblur=settingsBlurHandler;onEachLazy(settingsMenu.querySelectorAll("input"),el=>{el.onblur=settingsBlurHandler});settingsMenu.onblur=settingsBlurHandler}setTimeout(()=>{setEvents(settingsMenu);if(!isSettingsPage){displaySettings()}removeClass(getSettingsButton(),"rotate")},0)})() \ No newline at end of file diff --git a/ch5/static.files/src-script-3280b574d94e47b4.js b/ch5/static.files/src-script-3280b574d94e47b4.js new file mode 100644 index 00000000..9ea88921 --- /dev/null +++ b/ch5/static.files/src-script-3280b574d94e47b4.js @@ -0,0 +1 @@ +"use strict";(function(){const rootPath=getVar("root-path");const NAME_OFFSET=0;const DIRS_OFFSET=1;const FILES_OFFSET=2;const RUSTDOC_MOBILE_BREAKPOINT=700;function closeSidebarIfMobile(){if(window.innerWidth"){addClass(document.documentElement,"src-sidebar-expanded");child.innerText="<";updateLocalStorage("source-sidebar-show","true")}else{removeClass(document.documentElement,"src-sidebar-expanded");child.innerText=">";updateLocalStorage("source-sidebar-show","false")}}function createSidebarToggle(){const sidebarToggle=document.createElement("div");sidebarToggle.id="src-sidebar-toggle";const inner=document.createElement("button");if(getCurrentValue("source-sidebar-show")==="true"){inner.innerText="<"}else{inner.innerText=">"}inner.onclick=toggleSidebar;sidebarToggle.appendChild(inner);return sidebarToggle}function createSrcSidebar(){const container=document.querySelector("nav.sidebar");const sidebarToggle=createSidebarToggle();container.insertBefore(sidebarToggle,container.firstChild);const sidebar=document.createElement("div");sidebar.id="src-sidebar";let hasFoundFile=false;const title=document.createElement("div");title.className="title";title.innerText="Files";sidebar.appendChild(title);Object.keys(srcIndex).forEach(key=>{srcIndex[key][NAME_OFFSET]=key;hasFoundFile=createDirEntry(srcIndex[key],sidebar,"",hasFoundFile)});container.appendChild(sidebar);const selected_elem=sidebar.getElementsByClassName("selected")[0];if(typeof selected_elem!=="undefined"){selected_elem.focus()}}const lineNumbersRegex=/^#?(\d+)(?:-(\d+))?$/;function highlightSrcLines(match){if(typeof match==="undefined"){match=window.location.hash.match(lineNumbersRegex)}if(!match){return}let from=parseInt(match[1],10);let to=from;if(typeof match[2]!=="undefined"){to=parseInt(match[2],10)}if(to{onEachLazy(e.getElementsByTagName("a"),i_e=>{removeClass(i_e,"line-highlighted")})});for(let i=from;i<=to;++i){elem=document.getElementById(i);if(!elem){break}addClass(elem,"line-highlighted")}}const handleSrcHighlight=(function(){let prev_line_id=0;const set_fragment=name=>{const x=window.scrollX,y=window.scrollY;if(browserSupportsHistoryApi()){history.replaceState(null,null,"#"+name);highlightSrcLines()}else{location.replace("#"+name)}window.scrollTo(x,y)};return ev=>{let cur_line_id=parseInt(ev.target.id,10);if(isNaN(cur_line_id)||ev.ctrlKey||ev.altKey||ev.metaKey){return}ev.preventDefault();if(ev.shiftKey&&prev_line_id){if(prev_line_id>cur_line_id){const tmp=prev_line_id;prev_line_id=cur_line_id;cur_line_id=tmp}set_fragment(prev_line_id+"-"+cur_line_id)}else{prev_line_id=cur_line_id;set_fragment(cur_line_id)}}}());window.addEventListener("hashchange",()=>{const match=window.location.hash.match(lineNumbersRegex);if(match){return highlightSrcLines(match)}});onEachLazy(document.getElementsByClassName("src-line-numbers"),el=>{el.addEventListener("click",handleSrcHighlight)});highlightSrcLines();window.createSrcSidebar=createSrcSidebar})() \ No newline at end of file diff --git a/ch5/static.files/storage-fec3eaa3851e447d.js b/ch5/static.files/storage-fec3eaa3851e447d.js new file mode 100644 index 00000000..a687118f --- /dev/null +++ b/ch5/static.files/storage-fec3eaa3851e447d.js @@ -0,0 +1 @@ +"use strict";const builtinThemes=["light","dark","ayu"];const darkThemes=["dark","ayu"];window.currentTheme=document.getElementById("themeStyle");const settingsDataset=(function(){const settingsElement=document.getElementById("default-settings");return settingsElement&&settingsElement.dataset?settingsElement.dataset:null})();function getSettingValue(settingName){const current=getCurrentValue(settingName);if(current===null&&settingsDataset!==null){const def=settingsDataset[settingName.replace(/-/g,"_")];if(def!==undefined){return def}}return current}const localStoredTheme=getSettingValue("theme");function hasClass(elem,className){return elem&&elem.classList&&elem.classList.contains(className)}function addClass(elem,className){if(elem&&elem.classList){elem.classList.add(className)}}function removeClass(elem,className){if(elem&&elem.classList){elem.classList.remove(className)}}function onEach(arr,func,reversed){if(arr&&arr.length>0){if(reversed){for(let i=arr.length-1;i>=0;--i){if(func(arr[i])){return true}}}else{for(const elem of arr){if(func(elem)){return true}}}}return false}function onEachLazy(lazyArray,func,reversed){return onEach(Array.prototype.slice.call(lazyArray),func,reversed)}function updateLocalStorage(name,value){try{window.localStorage.setItem("rustdoc-"+name,value)}catch(e){}}function getCurrentValue(name){try{return window.localStorage.getItem("rustdoc-"+name)}catch(e){return null}}const getVar=(function getVar(name){const el=document.querySelector("head > meta[name='rustdoc-vars']");return el?el.attributes["data-"+name].value:null});function switchTheme(newThemeName,saveTheme){if(saveTheme){updateLocalStorage("theme",newThemeName)}document.documentElement.setAttribute("data-theme",newThemeName);if(builtinThemes.indexOf(newThemeName)!==-1){if(window.currentTheme){window.currentTheme.parentNode.removeChild(window.currentTheme);window.currentTheme=null}}else{const newHref=getVar("root-path")+newThemeName+getVar("resource-suffix")+".css";if(!window.currentTheme){if(document.readyState==="loading"){document.write(``);window.currentTheme=document.getElementById("themeStyle")}else{window.currentTheme=document.createElement("link");window.currentTheme.rel="stylesheet";window.currentTheme.id="themeStyle";window.currentTheme.href=newHref;document.documentElement.appendChild(window.currentTheme)}}else if(newHref!==window.currentTheme.href){window.currentTheme.href=newHref}}}const updateTheme=(function(){const mql=window.matchMedia("(prefers-color-scheme: dark)");function updateTheme(){if(getSettingValue("use-system-theme")!=="false"){const lightTheme=getSettingValue("preferred-light-theme")||"light";const darkTheme=getSettingValue("preferred-dark-theme")||"dark";updateLocalStorage("use-system-theme","true");switchTheme(mql.matches?darkTheme:lightTheme,true)}else{switchTheme(getSettingValue("theme"),false)}}mql.addEventListener("change",updateTheme);return updateTheme})();if(getSettingValue("use-system-theme")!=="false"&&window.matchMedia){if(getSettingValue("use-system-theme")===null&&getSettingValue("preferred-dark-theme")===null&&darkThemes.indexOf(localStoredTheme)>=0){updateLocalStorage("preferred-dark-theme",localStoredTheme)}}updateTheme();if(getSettingValue("source-sidebar-show")==="true"){addClass(document.documentElement,"src-sidebar-expanded")}window.addEventListener("pageshow",ev=>{if(ev.persisted){setTimeout(updateTheme,0)}}) \ No newline at end of file diff --git a/ch5/static.files/wheel-7b819b6101059cd0.svg b/ch5/static.files/wheel-7b819b6101059cd0.svg new file mode 100644 index 00000000..83c07f63 --- /dev/null +++ b/ch5/static.files/wheel-7b819b6101059cd0.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/ch5/storage.js b/ch5/storage.js deleted file mode 100644 index 07f8962f..00000000 --- a/ch5/storage.js +++ /dev/null @@ -1 +0,0 @@ -"use strict";const darkThemes=["dark","ayu"];window.currentTheme=document.getElementById("themeStyle");window.mainTheme=document.getElementById("mainThemeStyle");window.RUSTDOC_MOBILE_BREAKPOINT=701;const settingsDataset=(function(){const settingsElement=document.getElementById("default-settings");if(settingsElement===null){return null}const dataset=settingsElement.dataset;if(dataset===undefined){return null}return dataset})();function getSettingValue(settingName){const current=getCurrentValue(settingName);if(current!==null){return current}if(settingsDataset!==null){const def=settingsDataset[settingName.replace(/-/g,"_")];if(def!==undefined){return def}}return null}const localStoredTheme=getSettingValue("theme");const savedHref=[];function hasClass(elem,className){return elem&&elem.classList&&elem.classList.contains(className)}function addClass(elem,className){if(!elem||!elem.classList){return}elem.classList.add(className)}function removeClass(elem,className){if(!elem||!elem.classList){return}elem.classList.remove(className)}function onEach(arr,func,reversed){if(arr&&arr.length>0&&func){if(reversed){const length=arr.length;for(let i=length-1;i>=0;--i){if(func(arr[i])){return true}}}else{for(const elem of arr){if(func(elem)){return true}}}}return false}function onEachLazy(lazyArray,func,reversed){return onEach(Array.prototype.slice.call(lazyArray),func,reversed)}function updateLocalStorage(name,value){try{window.localStorage.setItem("rustdoc-"+name,value)}catch(e){}}function getCurrentValue(name){try{return window.localStorage.getItem("rustdoc-"+name)}catch(e){return null}}function switchTheme(styleElem,mainStyleElem,newTheme,saveTheme){const newHref=mainStyleElem.href.replace(/\/rustdoc([^/]*)\.css/,"/"+newTheme+"$1"+".css");if(saveTheme){updateLocalStorage("theme",newTheme)}if(styleElem.href===newHref){return}let found=false;if(savedHref.length===0){onEachLazy(document.getElementsByTagName("link"),el=>{savedHref.push(el.href)})}onEach(savedHref,el=>{if(el===newHref){found=true;return true}});if(found){styleElem.href=newHref}}function useSystemTheme(value){if(value===undefined){value=true}updateLocalStorage("use-system-theme",value);const toggle=document.getElementById("use-system-theme");if(toggle&&toggle instanceof HTMLInputElement){toggle.checked=value}}const updateSystemTheme=(function(){if(!window.matchMedia){return()=>{const cssTheme=getComputedStyle(document.documentElement).getPropertyValue("content");switchTheme(window.currentTheme,window.mainTheme,JSON.parse(cssTheme)||"light",true)}}const mql=window.matchMedia("(prefers-color-scheme: dark)");function handlePreferenceChange(mql){const use=theme=>{switchTheme(window.currentTheme,window.mainTheme,theme,true)};if(getSettingValue("use-system-theme")!=="false"){const lightTheme=getSettingValue("preferred-light-theme")||"light";const darkTheme=getSettingValue("preferred-dark-theme")||"dark";if(mql.matches){use(darkTheme)}else{use(lightTheme)}}else{use(getSettingValue("theme"))}}mql.addListener(handlePreferenceChange);return()=>{handlePreferenceChange(mql)}})();function switchToSavedTheme(){switchTheme(window.currentTheme,window.mainTheme,getSettingValue("theme")||"light",false)}if(getSettingValue("use-system-theme")!=="false"&&window.matchMedia){if(getSettingValue("use-system-theme")===null&&getSettingValue("preferred-dark-theme")===null&&darkThemes.indexOf(localStoredTheme)>=0){updateLocalStorage("preferred-dark-theme",localStoredTheme)}updateSystemTheme()}else{switchToSavedTheme()}if(getSettingValue("source-sidebar-show")==="true"){addClass(document.documentElement,"source-sidebar-expanded")}window.addEventListener("pageshow",ev=>{if(ev.persisted){setTimeout(switchToSavedTheme,0)}}) \ No newline at end of file diff --git a/ch5/toggle-minus.svg b/ch5/toggle-minus.svg deleted file mode 100644 index 73154788..00000000 --- a/ch5/toggle-minus.svg +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file diff --git a/ch5/toggle-plus.svg b/ch5/toggle-plus.svg deleted file mode 100644 index 08b17033..00000000 --- a/ch5/toggle-plus.svg +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file diff --git a/ch5/wheel.svg b/ch5/wheel.svg deleted file mode 100644 index 01da3b24..00000000 --- a/ch5/wheel.svg +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file