Getting Started with QNX Neutrino - QNX Software Systems

More documents

Recommendations

Info

QNX 4 and Neutrino © 2009, QNX Software Systems GmbH & Co. KG. • portable architecture; currently supports MIPS, PPC, SH4 and ARM processors as well as x86 • supports SMP • more documentation While some of these improvements are “free,” meaning that there are no compatibility issues (for example, POSIX pthreads weren’t supported under QNX 4), some things did require fundamental changes. I’ll briefly mention the classes of changes that were required, and then we’ll look in detail at the compatibility issues caused as well as suggestions on how to port to Neutrino (or keep your code portable between the two). Embeddability Neutrino totally redesigned the way that the operating system was embedded. Under QNX 4, in the original release, it was marginally embeddable. Then Neutrino came along, designed to be embeddable. As a bonus, QNX 4 underwent some changes as a result of the experience gained in Neutrino, and now QNX 4 is vastly more embeddable than it had been. In any event, embedding QNX 4 versus embedding Neutrino is almost like night and day. QNX 4 has no real support for things like: • kernel callouts (interrupt, timer) • startup configurability • image filesystem whereas Neutrino does. The definitive book on that subject is QSS’s Building Embedded Systems. Thread support QNX 4 had a function called tfork() that let you use “threads” by creating a process with its code and data segments mapped to the same memory locations as the creating process. This gave the illusion of a thread by creating a process, and then changing the characteristics of the newly created process to make it look like a thread. While there is a thread library available for QNX 4 on QSS’s update system, the kernel itself doesn’t support threads directly. Under Neutrino, the POSIX “pthread” model is used for all threading. This means that you’ll see (and have seen in this book) familiar function calls like pthread_create(), pthread_mutex_lock(), and others. Message passing While the impact of threads on message passing may seem minimal, it resulted in a fundamental change to the way message passing was done (not to the fundamental concepts of message passing, like SEND/RECEIVE/REPLY, but to the implementation). Under QNX 4, messages were targeted at process IDs. To send a message, you simply found the process ID of the target and did your Send(). For servers to receive a 288 Appendix: A • QNX 4 to Neutrino April 30, 2009
© 2009, QNX Software Systems GmbH & Co. KG. QNX 4 and Neutrino message under QNX 4 they just did a Receive(). This would block until a message arrived. The server would then reply with the Reply() function. Under Neutrino, message passing is identical (different function names, though). What’s changed is the mechanism. The client now has to create a connection to a server before it can do the standard message-passing functions. And the server has to create a channel before it can do the standard message-passing functions. Note that the QNX 4 Creceive() function, which would do a non-blocking Receive(), is missing from Neutrino. We generally discourage such “polling” functions, especially when you can start a thread, but if you really insist on performing a non-blocking MsgReceive(), you should take a look at the Clocks, Timers, and Getting a Kick Every So Often chapter (under “Kernel timeouts”) for more information. For the short story version, here’s the relevant code sample: TimerTimeout (CLOCK_REALTIME, _NTO_TIMEOUT_RECEIVE, NULL, NULL, NULL); rcvid = MsgReceive (... Pulses and events QNX 4 provided something called a “proxy.” A proxy is best described as a “canned” (or “fixed”) message, which could be sent by processes or kernel services (like a timer or interrupt service routine) to the owner of the proxy. The proxy is non-blocking for the sender and would arrive just like any other message. The way to identify a proxy (as opposed to another process actually sending a message) was to either look at the proxy message contents (not 100% reliable, as a process could send something that looked like the contents of the proxy) or to examine the process ID associated with the message. If the process ID of the message was the same as the proxy ID, then you could be assured it was a proxy, because proxy IDs and process IDs were taken from the same pool of numbers (there’d be no overlap). Neutrino extends the concept of proxies with “pulses.” Pulses are still non-blocking messages, they can still be sent from a thread to another thread, or from a kernel service (like the timer and ISR mentioned above for proxies) to a thread. The differences are that while proxies were of fixed-content, Neutrino pulses are fixed-length, but the content can be set by the sender of the pulse at any time. For example, an ISR could save away a key piece of data into the pulse and then send that to a thread. Under QNX 4, some services were able to deliver a signal or a proxy, while other services were able to deliver only one or the other. To complicate matters, the delivery of these services was usually done in several different ways. For example, to deliver a signal, you’d have to use the kill() function. To deliver a proxy or signal as a result of a timer, you’d have to use a negative signal number (to indicate it was a proxy) or a positive signal number (to indicate it was a signal). Finally, an ISR could deliver only a proxy. April 30, 2009 Appendix: A • QNX 4 to Neutrino 289
Page 1 and 2:
QNX Neutrino RTOS Getting Started w
Page 3 and 4:
Contents About This Guide xi What y
Page 5 and 6:
© 2009, QNX Software Systems GmbH
Page 7 and 8:
Page 9 and 10:
List of Figures A process as a cont
Page 11:
About This Guide April 30, 2009 Abo
Page 14 and 15:
Typographical conventions © 2009,
Page 17:
Foreword to the First Edition by Pe
Page 20 and 21:
Page 23 and 24:
Page 25 and 26:
Page 27:
Page 31 and 32:
Page 33 and 34:
Page 35 and 36:
Page 37 and 38:
Page 39 and 40:
Page 41 and 42:
Page 43 and 44:
Page 45 and 46:
Page 47 and 48:
Page 49 and 50:
Page 51 and 52:
Page 53 and 54:
Page 55 and 56:
Page 57 and 58:
Page 59 and 60:
Page 61 and 62:
Page 63 and 64:
Page 65 and 66:
Page 67 and 68:
Page 69 and 70:
Page 71 and 72:
Page 73 and 74:
Page 75 and 76:
Page 77 and 78:
Page 79 and 80:
Page 81 and 82:
Page 83 and 84:
Page 85 and 86:
Page 87 and 88:
Page 89 and 90:
Page 91 and 92:
Page 93 and 94:
Page 95:
Chapter 2 Message Passing In this c
Page 98 and 99:
Message passing and client/server
Page 100 and 101:
Message passing and client/server
Page 102 and 103:
Multiple threads © 2009, QNX Softw
Page 104 and 105:
Multiple threads © 2009, QNX Softw
Page 106 and 107:
Using message passing © 2009, QNX
Page 108 and 109:
Page 110 and 111:
Page 112 and 113:
Page 114 and 115:
Page 116 and 117:
Page 118 and 119:
Page 120 and 121:
Page 122 and 123:
Page 124 and 125:
Page 126 and 127:
Page 128 and 129:
Page 130 and 131:
Pulses © 2009, QNX Software System
Page 132 and 133:
Page 134 and 135:
Page 136 and 137:
Page 138 and 139:
Page 140 and 141:
Message passing over a network © 2
Page 142 and 143:
Page 144 and 145:
Page 146 and 147:
Priority inheritance © 2009, QNX S
Page 148 and 149:
Priority inheritance © 2009, QNX S
Page 151:
Chapter 3 Clocks, Timers, and Getti
Page 154 and 155:
Clocks and timers © 2009, QNX Soft
Page 156 and 157:
Page 158 and 159:
Page 160 and 161:
Page 162 and 163:
Using timers © 2009, QNX Software
Page 164 and 165:
Page 166 and 167:
Page 168 and 169:
Page 170 and 171:
Page 172 and 173:
Page 174 and 175:
Page 176 and 177:
Advanced topics © 2009, QNX Softwa
Page 178 and 179:
Page 180 and 181:
Page 183:
Chapter 4 Interrupts In this chapte
Page 186 and 187:
Neutrino and interrupts © 2009, QN
Page 188 and 189:
Page 190 and 191:
Page 192 and 193:
Writing interrupt handlers © 2009,
Page 194 and 195:
Page 196 and 197:
Page 198 and 199:
Page 200 and 201:
TIME TIME Writing interrupt handler
Page 202 and 203:
Page 204 and 205:
Summary © 2009, QNX Software Syste
Page 207 and 208:
Page 209 and 210:
Page 211 and 212:
Page 213 and 214:
Page 215 and 216:
Page 217 and 218:
Page 219 and 220:
Page 221 and 222:
Page 223 and 224:
Page 225 and 226:
Page 227 and 228:
Page 229 and 230:
Page 231 and 232:
Page 233 and 234:
Page 235 and 236:
Page 237 and 238:
Page 239 and 240:
Page 241 and 242:
Page 243 and 244:
Page 245 and 246:
Page 247 and 248:
Page 249 and 250:
Page 251 and 252:
Page 253 and 254: © 2009, QNX Software Systems GmbH
Page 299: © 2009, QNX Software Systems GmbH
Page 303: © 2009, QNX Software Systems GmbH
Page 319: Appendix B Calling 911 In this appe
Page 322 and 323: Seeking professional help © 2009,
Page 324 and 325: Seeking professional help © 2009,
Page 327: Appendix C Sample Programs In this
Page 330 and 331: atoz.c © 2009, QNX Software System
Page 332 and 333: atoz.c © 2009, QNX Software System
Page 334 and 335: time1.c © 2009, QNX Software Syste
Page 336 and 337: time1.c © 2009, QNX Software Syste
Page 338 and 339: tp1.c © 2009, QNX Software Systems
Page 340 and 341: tt1.c © 2009, QNX Software Systems
Page 351 and 352: Index ! /dev/null resource manager
Page 355 and 356:
Page 357 and 358:
Page 359 and 360:
Page 361 and 362:
Page 363 and 364:
Page 365 and 366:
Page 367 and 368:
Page 369 and 370:
Page 371 and 372:
Page 373 and 374:
Page 375 and 376:
Page 377 and 378:
Page 379 and 380:
Page 381 and 382:
Page 383 and 384:
Page 385 and 386:
Page 387 and 388:
show all

Getting Started with QNX Neutrino - QNX Software Systems

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?