Windows Internals 3

Windows is a large and complex operating system. Understanding the way it works can help developers get the most out of it. This is a continuation course following Windows Internals 2
Course info
Rating
(118)
Level
Advanced
Updated
Feb 12, 2014
Duration
5h 16m
Table of contents
Services (part 1)
Services (part 2)
The I/O System (Part 1)
The I/O System (Part 2)
Device Drivers (Part 1)
Device Drivers (Part 2)
Writing Software Device Drivers (Part 1)
Writing Software Device Drivers (Part 2)
Description
Course info
Rating
(118)
Level
Advanced
Updated
Feb 12, 2014
Duration
5h 16m
Description

Software developers for Windows should understand the way Windows works, its mechanisms and algorithms, so they are able to write better software that can take advantage of Windows' strengths. The course deals with all the major terms in Windows, such as processes, threads, virtual memory and more. Whether you're a Win32 programmer, a .NET programmer or a device driver programmer, you should benefit from understanding Windows, which may help in troubleshooting difficult issues as well.

About the author
About the author

Pavel is a developer, trainer, author and speaker, specializing in Microsoft technologies. He's the co-author of "Windows Internals, 7th edition" (MS Press, 2017) and "WPF 4.5 Cookbook" (Packt, 2012).

More from the author
.NET Interoperability Fundamentals
Intermediate
5h 45m
Sep 20, 2014
More courses by Pavel Yosifovich
Section Introduction Transcripts
Section Introduction Transcripts

Services (part 1)
Hi, my name is Pavel, and I'd like to welcome you to this Windows Internals 3 course. This is a follow-up on the Windows Internals and Windows Internals 2 courses, and ideally you've watched these courses already. That's important because we're going to use a lot of the concepts we've learned in the previous courses in this third installment. In this first and second module, we'll discuss Services. And the word Services is highly overloaded in the software industry so we're going to discuss Windows Services, also known in the Unix world as Demons. We'll start by introducing Services and what they can do. Then we'll look at how to install a Service, followed by how to configure a Service, and finally how a Service is architectured. In the following module, we'll see an example of how to write a Service and look at some more options for using Services.

Services (part 2)
Hi and welcome to the second module of Windows Internals 3. In this module, we'll continue discussing Services. First, we'll take a look at creating a Simple Service in Win32 and a simple client to communicate with the service. Then we'll discuss the various ways that we can Control Service using particular APIs. We'll take a brief look at the possible Service Accounts and what's best to use in which scenario. And then we'll discuss the idea of sharing several services running under the same process, the advantages and disadvantages of that approach. Finally, we'll discuss Trigger Start Services, a relatively new mechanism to trigger starting or stopping of services. And finally we'll sum things up. So, let's begin.

The I/O System (Part 1)
Hi and welcome to the third module for using terminals three. In this module we will start to discuss the I/O systems in Windows. Specifically we will provide a brief introduction on what is the I/O system exactly and what's its role. Then we'll look at the components, that comprise the I/O System within Windows, mostly in the kernel, but some of them are actually in user space. And then we'll discuss device drivers and their role in the system. We'll take a look at Plug and Play and how it's used to enumerate devices and find the appropriate drivers to load. We'll take a look at the enumeration process, where the system builds a tree of devices and loads the appropriate drivers in some way using the Plug and Play manager and bus drivers. And finally we'll sum things up.

The I/O System (Part 2)
Hi and welcome to the fourth module of the Windows Internals 3 course. In this module, we'll continue looking at the I/O system in Windows. Specifically, we'll take a look at the important registry keys that are related to device enumeration and how the plug and play manager finds the appropriate drivers. We'll take a look at our request package, which is the main delivery mechanism of I/O operations in Windows. We'll look at how to access devices in the general case. And finally, we'll take a look at how to initiate asynchronous I/O from user mode APIs. And of course, we'll sum things up.

Device Drivers (Part 1)
Hi and welcome to Module five of the Windows Internals 3 course. In this module and the next, we'll dig deeper into device drivers. We'll take a look at what device drivers really are and how we can identify them. We'll take a look at device driver types and how to recognize such drivers. We'll look at how a driver is constructed. What's the components of a driver. We'll look at how a typical function driver processes IRPs. We'll see how our manager helps us access user mode buffers from arbitrary thread context and high RQL. And then we'll sum things up. So let's begin.

Device Drivers (Part 2)
Hi, and welcome to module six of the Windows Internals Three course. In this module, we'll continue discussing device drivers. Specifically, we'll take a look at the Windows Driver Model and why it was constructed. Then we'll look at the Windows Driver Foundation, which replaces the Windows driver model and also provides a way to create certain types of drivers in user mode. We'll describe how driver installation works and what are the keys files there? And finally we'll take a look at the Driver Verifier which is a powerful tool to examine and test driver operation. And of course, we'll sum things up.

Writing Software Device Drivers (Part 1)
Hi, and welcome to Module seven of the Windows Internals 3 course. In this module, we'll start to write a software driver from scratch. That driver will be able to do some things that are simply not possible to do from User Mode. Specifically, we'll start by introducing what a software driver is and how do we write one. Then we'll take a look at the DriverEntry function which is the main function of the driver, and see what its purpose is. We'll take a look at the opposite of the DriverEntry function which is the unload routine that needs to do some clean up. And then we'll see how to install a software driver. We'll see that it's very similar to installing a service. Then we'll take a look at the way to expose functionality from a driver using something known as Dispatch Routines. And we'll see how to write a test client for the driver to see if it operates correctly. And then we'll sum things up as preparation for our next module.

Writing Software Device Drivers (Part 2)
Hi, and welcome to the last module of the Windows Internals 3 course. In this module, we'll continue writing our software driver that we started in the previous module. What we want to do is complete implementing the driver using the DeviceIoControl routine, which should be the main most important functionality within the driver, the other things being just kind of boilerplate. Finally, we want to test the driver and set up a kernel debugging environment so we can debug the driver if anything goes wrong. So, we'll like to see how to do that with a virtual machine and then to do actual debugging by using break points, looking at variables and so on. Just as we do in normal user mode debugging. And then we'll summarize the procedures to write a software driver. So, let's begin.