Customer Reviews

Programming the Microsoft Windows Driver Model

5 star:		(8)
4 star:		(1)
3 star:		(2)
2 star:		(2)
1 star:		(1)

 

 

If you already know how to write WDM device drivers, you may or may not need this book.

If you do not know how to write WDM device drivers, you would do yourself
a big favor by avoiding this book. It is so carelessly edited and
organized that I would feel justified in billing Walter Oney and his
publishers back for the time I have wasted dealing with things like this:

From page 184: ..."In fact, sometimes the easiest way to commence a new operation is to store
some state information in your device extension and then fake an
interrupt. Since either of these approaches needs to be carried out under
protection of the same spin lock that protects your ISR..."

"Fake and interrupt?" This term is not defined or explained anywhere in the book that I could
find within an hour's search.

"...the same spin lock that protects your ISR," is explained 121 pages later on page 305,
where it says "...(because the I/O Manager automatically allocates [a spin
lock] for you.)"

There are 26 pages of errata downloadable from Oney's web site. I printed
out the file, and I have to check it every page or two to make sure the
information on the page I am reading is correct.

If you want to spend your time sorting through this mess
while introducing yourself to a topic as arcane as WDM, be my guest.

You have been warned.

Having read this book half way, I believe it is intended for experienced developers instead of for beginners in device programming. Rather than offering a structural and formal introduction to the subject, it stresses on tricks and hints on selected topics like synchronization, pnp, read/write, etc.

I now go for the DDK documentation for a more fundamental treatment. It cleared up instantly some of the questions built up as I read through the first five chapters of the book, like how a user mode application calls up the kernal mode driver. Nevertheless the author does give an authoritative insight in WDM programming. Incidentally, it is a matter of taste whether you like his informal writing style.

As a beginner at the moment, I rated this book three stars. I might rate it differently when I returned to the book later.

Walter Oney is an expert who doesn't talk down to you. There's a lot of gold in this well-written book, but to extract it happily you'll need a strong background in Windows programming, including first and foremost a couple of years of professional driver-writing experience for Win9X/NT platforms; in a few places, some knowledge of COM and MFC will also be helpful. Plug and Play, power management, and USB issues are covered in detail, as well as driver basics (from an advanced perspective), the intricacies of cancelling IRPs, etc.

I like Oney's approach to teaching -- he concentrates on the logic of the few dozen basic steps needed to write a driver, leaving it to the samples on the accompanying CD to flesh out the skeleton. This has the advantage of highlighting the mechanics, and the often convoluted reasoning behind them, without sacrificing completeness. He identifies and analyzes many potential race conditions and other pitfalls that you might not think of on your own.

One of the best things about the book is the tips and sidebars. Some examples: why you should use the PAGED_CODE macro and Driver Verifier when using Soft-Ice/W on Win2k; the hazards of using DDK "function calls" that are actually macros; how to ship a single binary for both Win2000 and Win98, given that Win98 doesn't support some key functions (such as those involving IO_REMOVE_LOCK) -- the book suggests writing a VDD with stubs for the missing functions, as explained in Appendix A. The sample code also contains very instructive workarounds for the shortcomings of Win98. Another strong point is the DEVQUEUE code that Oney has developed to extend the standard Windows driver model to handle PlugandPlay. In addition to including the code on the CD, he gives a detailed and highly instructive discussion in the text. DEVQUEUE is a useful tool that can be taken over as-is in your own projects.

Once you've finished this book, you'll be writing much more solid code and have enough technique to pick and choose among methods of your choice, rather than feeling cornered and boxed-in. Oney maintains a web site with errata and updates for the book and code samples (for instance, the stub VDD is now replaced by a filter driver to avoid the need to reboot).

This book was a valuable resource for my successful driver development project.

For newbie's, the book is a great companion to the DDK. The text provides simple and concise sample code. The examples on the CD-ROM are a great way to start exploring driver programming concepts using a kernel debugger. The DDK samples are far too complicated for understanding the fundamentals, so use the book to get started and then the DDK samples will be much easier to comprehend.

I recommend that you read through the entire book at a high enough level that you don't get caught up in the details. Next, find the chapter and sample driver that is most appropriate for your task and get started. Throughout the rest of development, you'll reference various parts of the book to understand the details and avoid the hidden pitfalls in kernel mode programming.

For experts, the book provides comprehensive treatment of the topic. It's full of tips and suggestions based on real-world experience. Many of the driver components on the CD-ROM can be integrated into real drivers in order to reduce development time and complexity. If you are creating a production driver that you intend to ship to real customers, the book will also provide you many options for creating a top-notch user experience during the install process. WHQL and driver security issues are addressed as well.

The author updates the CD-ROM sources in service packs located on the web site. These updates are based on his continuing work and feedback from readers.

If your developing device drivers in 2000/2001 for a Windows operating system then this book is simply a must have. I purchased Chris Cant's book first because I had the misimpression that Oney's book was written a year earlier than it was and didn't really address Win2K as well as it does. I couldn't have been more wrong. Just flipping though the pages alone, it seems bigger and more authoritative. Code snips are kept quite small and the numerous diagrams and tables mean you don't have to keep refering back to the DDK as much or seaching for the right header file to find the definition of a perticular structure.

You might also want to consider investing in some colored tabs at your local office supply store because you well spend a lot of time flipping between sections.

If you can only get one book, get this one, or at least get this one first. But quite honestly you really need both books because each has it's strengths and it really helps to have the same thing explained in different ways and words. Plus you can never have too much sample code.

I am borrowing a copy of this book at work, and I agree with the other reviewers that its helpful, and it doesnt "talk down"

But it can get quite rambly, the IO Request Chapter is a great example of this.

That being said I actually tried to include his DEVQUEUE in my driver code im using at work...Ive been programming for 10+ years so im not a slouch.

Problems:
1) C code written using C++ rules. This is annoying.
2) Doesn't compile at tighter warning levels...LOTS of warnings
3) Bug in DEVQUEUE initialization sent me on an IRP goosechase for good part of a day, and YES I did download his code service packs first. Watch out for stallcount being initialized to 1, StartNextPacket will refuse to run unless you change this to zero.

Is one of several *essential* books for WDM Programming. Also see Chris Cant's book. Walter's is a bit more detailed, Chris's more approachable. You need both.

This is an extremely difficult topic, and Walter does a good job of making it understandable.

USB Chapter is also quite good.

This book is written in an extremely hard to read style, with long and convoluted sentences.

The writing style is almost unbearably boring. It you thought Hardy's "Return of the Native" was too fast paced, this is the book for you!

It also tends to explain the micro details without clearly explaining how it all fits together. In this respect, it almost assumes you have read and understood the Device Driver Kits, although the reader will be generally looking for help getting started with the DDKs.

There also seem to be a lot of omissions, in that it does not do a very good job of getting you started. Want to write a winmodem driver? This book gives you no idea where to start.

Having said all that, you probably need this book if you are writing a WDM driver. It does have a lot of useful information and tips. However it assumes you are a guru already.

Walter Oney is an expert who doesn't talk down to you. There's a lot of gold in this well-written book, but to extract it happily you'll need a strong background in Windows programming, including first and foremost a couple of years of professional driver-writing experience for Win9X/NT platforms; in a few places, some knowledge of COM and MFC will also be helpful. Plug and Play, power management, and USB issues are covered in detail, as well as driver basics (from an advanced perspective), the intricacies of cancelling IRPs, etc.

I like Oney's approach to teaching -- he concentrates on the logic of the few dozen basic steps needed to write a driver, leaving it to the samples on the accompanying CD to flesh out the skeleton. This has the advantage of highlighting the mechanics, and the often convoluted reasoning behind them, without sacrificing completeness. He identifies and analyzes many potential race conditions and other pitfalls that you might not think of on your own.

One of the best things about the book is the tips and sidebars. Some examples: why you should use the PAGED_CODE macro and Driver Verifier when using Soft-Ice/W on Win2k; the hazards of using DDK "function calls" that are actually macros; how to ship a single binary for both Win2000 and Win98, given that Win98 doesn't support some key functions (such as those involving IO_REMOVE_LOCK) -- the book suggests writing a VDD with stubs for the missing functions, as explained in Appendix A. The sample code also contains very instructive workarounds for the shortcomings of Win98. Another strong point is the DEVQUEUE code that Oney has developed to extend the standard Windows driver model to handle PlugandPlay. In addition to including the code on the CD, he gives a detailed and highly instructive discussion in the text. DEVQUEUE is a useful tool that can be taken over as-is in your own projects.

Once you've finished this book, you'll be writing much more solid code and have enough technique to pick and choose among methods of your choice, rather than feeling cornered and boxed-in. Oney maintains a web site with errata and updates for the book and code samples (for instance, the stub VDD is now replaced by a filter driver to avoid the need to reboot).

Lots of good information is in this book, but you
would have to be an experienced driver developer to understand.

Only chapters 1-3 are aimed at beginners.

The problem is the author jumps right into the hardest part
first.

Also, the author shows the wrong way of doing things first. That
makes this an extremely difficult read.

Some of the topics could have been simplified.

There is good examples, and software with the book. Otherwise, I would
have given it one star.