25 Jun 2009
[box]
Home schooling
Georgia College Foundation hopes to save home of pioneering black educator
By Carl Lewis
<EMAIL_ADDRESS>Thursday, Jun. 25, 2009
[/box]
MILLEDGEVILLE — Fifteen-year-old Deandre Hooks crouched on the porch of a crumbling, wood-planked house Wednesday morning to complete a writing assignment.
The house was nothing special and the heat was blistering, but it didn’t seem to bother him. In fact, he felt perfectly at home.
“I’m meant to be here right now,” Hooks said. “It’s part of who I am.”
It’s the same porch that black students like Hooks sat on 100 years ago.
Back then, the four-bedroom house on Clarke Street belonged to Sallie Ellis Davis, one of the first black educators in Georgia. Davis often mentored students at the house, which she lived in until her death in 1950.
But for many years, the historic home has been left to decay.
Now, officials from Georgia College & State University and the Sallie Ellis Davis Foundation are trying to raise money to renovate the house and open it as an African-American cultural center.
In 2008, the Georgia Trust added the Davis house to its “Places in Peril” list because of the structure’s deteriorating condition.
“This is an important piece of African-American history that we desperately need to preserve,” Judy Bailey, a spokeswoman for the college, said.
Bailey said it will cost an estimated $380,000 to renovate the home and $25,000 to stabilize it. So far, the foundation has raised about $15,000.
“We’re looking for all the help we can get. We’ve got a long way to go, but we have to make sure we’re able to save this place,” Bailey said.
Davis was born in Milledgeville in 1877 to a black mother and an Irish father, Bailey said.
She attended the Eddy School, where she later served as teacher and principal for more than 50 years.
Her house, which was built in 1890, changed hands numerous times before Georgia College purchased it in 1989.
Bailey said she hopes the Davis house will inspire people to follow after Sallie’s legacy and enter the field of education.
“Sallie Davis educated black students during a period of time when they didn’t have access to education. Hopefully, this house will motivate people to become educators themselves,” she said.
Camille Tyson is the principal of Early College, a school for students in seventh through 12th grades that holds classes at Georgia College. Tyson took her students to see the Davis home Wednesday.
“Either you can be a pioneer or a settler,” Tyson said. “Sallie Ellis Davis was a pioneer, and these students can be pioneers, too. That’s what I want them to realize.”
Hooks, who is a 10th-grader at Early College, said Davis’ story has inspired him to pursue a more ambitious future.
“I’m going to go to college and be a professional when I grow up. (Davis) spent her entire life trying to make sure our ancestors could do that, and I don’t want to let her down,” he said.
To make a donation to the Sallie Ellis Davis Foundation, call Lee Snelling at<PHONE_NUMBER>.
To contact writer Carl Lewis, call 744-4347.
18 Jun 2009
Outside the big box
Macon Mall turns to arts, entertainment to fill empty space
By Carl Lewis
<EMAIL_ADDRESS>Thursday, Jun. 18, 2009
Instead of showcasing his art in a downtown gallery like other artists, Michael Paul has chosen a different, less obvious place to share his work: the Macon Mall.
Paul is taking part in a new program called Artspace, which, along with a laser golf course, is one of the mall’s recent efforts to help reinvent itself.
The mall will offer 18 of its vacant stores in the east wing to artists, who can then transform the space into galleries, studios and offices. Three artists already have been recruited to display their work at the mall.
Mall manager Brian Olivi said he hopes the program will attract more people, increasing foot traffic and hopefully increasing sales for other mall retailers.
“We want to make the mall an art destination, to make it a fully functioning art colony for Middle Georgia with artists working on and showcasing their work around the clock,” Olivi said.
The idea for the program came from a sister mall in St. Louis, Olivi said. That mall was able to fill 45 empty stores with paintings, sculptures and dance studios.
“It’s a ‘win-win’ situation for everybody,” Olivi said. “It helps retailers, it helps artists and it even helps the community by providing a place to view local artwork,” Olivi said.
As part of the program, artists will receive discounted rent, flexible lease terms and 24/7 access to their spaces.
Paul said the mall is a perfect place for him because, unlike other galleries, it allows him to keep 100 percent of the profits from his paintings rather than being charged a portion of the sale.
“I’ve considered putting my art in some of the galleries downtown, but this makes a lot more financial sense,” Paul said.
Another benefit of locating at the mall, he said, is that it makes his artwork accessible to people who wouldn’t normally get the chance to see it.
“Hopefully, people who wouldn’t necessarily go to a downtown art gallery but who would go to Macy’s or Sears on Eisenhower Parkway will see my art and get inspired,” Paul said.
Artspace is not the mall’s only effort to increase its traffic. In April, the mall recruited Lunar Mini Golf, a laser putt-putt company out of Akron, Ohio, to open a location in the second level of the east wing, near the former Dillard’s. Olivi said the business has already brought a new demographic to the mall.
“We’ve seen so many parents bring their kids there that the (Lunar Mini Golf) course is now our No. 1 store in the whole mall,” he said.
Despite the traffic from the laser golf course and other retailers, Macon Mall may not have an easy time getting artists to invest in the program.
The 1.4 million-square-foot shopping center has at least 40 vacant storefronts and its sale is pending after going into foreclosure last July.
In 2007, Parisian, a 104,000-square-foot department store, closed its location in the mall. A year later, Dillard’s, another anchor store, relocated to the Shoppes at River Crossing, an outdoor shopping center in north Bibb County.
Macon Mall’s current management company, Chicago-based Jones Lang LaSalle Americas Inc., is “constantly out trying to attract new tenants,” Olivi said.
But in the past year, more than 35 stores have left the mall, according to the mall’s June 2008 directory compared with the June 2009 directory.
Some of the stores that have closed include Gap, Old Navy, Abercrombie & Fitch, Eddie Bauer, Lane Bryant, Wolf Camera, Starbucks, Piccadilly Cafeteria and Ruby Tuesday.
Last January, Dallas, Texas-based Movie Tavern Partners LP announced plans to open a 35,000-square-foot dinner theater in a portion of the former Parisian store, but after further consideration, backed out of plans for the location.
“The initial plans for the theater didn’t turn out to be cost-effective, so the ownership decided to table the project and look elsewhere,” Olivi said.
Olivi maintains, however, that Macon Mall still has the ability to attract new tenants in the future, especially if the condition of the national economy continues to improve.
“Last year alone, the mall had 13 million visits from a 22-county area. We are still the premier shopping center of Middle Georgia, and our losses have been mostly because of the national recession,” he said.
Olivi said the mall houses the only Macy’s department store in the region and that a new Verizon Wireless store just opened in the shopping center this month.
Melissa Goff, a spokeswoman for Macy’s, said the company has no plans to close its store in Macon Mall at the current time.
Unlike other retailers at the mall who lease their space, Macy’s owns the property where its store is located. At least seven of the mall’s retailers have duplicate stores at The Shoppes at River Crossing, including Aeropostale, American Eagle, Belk and Sunglass Hut.
Olivi said he is not worried that The Shoppes will replace the mall anytime soon.
“Nobody wants to spend two or three hours outdoors in the summer heat shopping there. Here at Macon Mall, it’s 72 degrees year-round,” he said.
To contact writer Carl Lewis, call 744-4347.
17 Jun 2009
[box]
Peach of a Party
Opening event a big draw at Georgia Peach Festival
The Sun News
By Carl Lewis
<EMAIL_ADDRESS>Wednesday, Jun. 17, 2009
[/box]
Ask Andrew Mathis to name his favorite food and he’ll tell you in an instant.
“It’s peaches, no question,” he said.
Mathis, a 70-year-old from Fort Valley, worked at a peach farm earlier in life and hasn’t missed a single Georgia Peach Festival since the event was launched in 1986.
Saturday, he made it out once again to the festival’s annual kickoff celebration at the Peach Shops of Byron.
“I wouldn’t miss it for anything,” he said.
The celebration began at 5 p.m. and featured live music, arts and crafts vendors, a fireworks show and a foam party for the kids.
Festival director Rich Bennett said it was the biggest crowd he’s ever seen for the celebration.
Brandi Trivette, a vendor at the event who sells peach-scented candles she makes at her home in Warner Robins, said the crowd was good for business.
“The peach candle has been a real hit tonight. People here in Peach County sure do love their peaches,” Trivette said.
But for some people, such as Janet Wynne and her husband, David, this year’s Peach Festival isn’t just about the titular fruit.
“Peaches are great, but we’re more into motorcycles, which is why we’re here,” she said.
Wynne said she had never been to the Peach Festival before until she rode in the festival’s first Poker Run Saturday morning.
On the other hand, Wynne’s 3-year-old daughter, Erika, said she loved the foam party.
“It looks like snow,” she said.
J.B. Roberson, an author from Warner Robins, was at the celebration signing copies of her latest children’s book, “Cuddlee Bugs: Revenge o’ the Peach Potion.”
“It’s a book that’s actually a lot about the Peach Festival,” she said.
The bands 2 Finger Jester and The Skeeterz performed free shows during the celebration.
“I was a little worried Two Finger Jester might be too loud for the festival, but everybody seemed to love them,” Bennett said. Mathis, however, said he was holding out for The Skeeterz, a more traditional country band.
“I may be old, but I love to dance when they play my sort of music,” he said.
The festival concluded with a fireworks display shot off from behind the shopping center.
“The fireworks are always the best part,” Bennett said.
As the kickoff to the festival drew to a close, Bennett said he held high hopes for the rest of it.
“This is looking like it might be one of the best Peach festivals yet. We’ve already gotten more involvement than last year,” he said.
To contact writer Carl Lewis, call 744-4347.
15 Jun 2009
Seeds of community
Vegetable gardens help bring Macon neighbors together
By Carl Lewis
<EMAIL_ADDRESS>Monday, Jun. 15, 2009
Tucked away in a vacant lot behind Centenary United Methodist Church on College Street sits a humble plot where pole beans, tomatoes, eggplant and okra grow.
"But what we're really growing is hope," said Mark Vanderhoek, founder of the Beall's Hill Community Garden.
Volunteers broke ground for the garden in May as a joint project of the church and the Beall's Hill Neighborhood Association.
The people who tend the garden share the food among themselves, and they donate much of the produce to the elderly and disabled in the community.
"The idea is to bring people in Beall's Hill neighborhood together through the garden. Everyone is the same when they have dirt on their hands," Vanderhoek said.
Vanderhoek got the idea for the garden last fall after hearing about a similar community garden in the Pleasant Hill neighborhood.
Inspired by what the Pleasant Hill garden had accomplished, Vanderhoek, a Mercer University employee, pushed for a garden in the Beall's Hill neighborhood near his workplace.
In February, he brought the idea before a meeting of the Beall's Hill Neighborhood Association, where it met across-the-board approval from residents.
Ellen Byron, the neighborhood association's president, then secured a $1,000 grant from the Knight Foundation in March to fund the project.
Since it opened May 2, volunteers have planted seven different vegetables and four different herbs.
"We're going to be making food baskets soon to take out to the people in the neighborhood who need to eat," Byron said.
She said she's excited at how the garden has given the neighborhood a sense of unity.
"A lot of different people live in Beall's Hill. This has given them all a common purpose," she said. "The first day we came out to work the garden, people who had never come out for anything in the community before showed up."
Mary Anne Richardson, who heads up the outreach ministry at Centenary, said she hopes students from Mercer University, which is across the street from the garden, will get involved.
David Davis is a professor of English at Mercer whose class volunteered at the Pleasant Hill community garden this spring.
He plans to have his freshman seminar class work at the new Beall's Hill garden in the fall.
"The class will have an environmental focus, and I think it'd be great for us to work in the garden," he said.
Naomi Johnson and Peter Gizens, owners of the Pleasant Hill garden, have been tending a patch of land on Craft Street since 2004.
Over the years, they've recruited about 30 steady volunteers to help them work the garden and have produced more than 1,000 pounds of vegetables to donate to people in need.
"All of our vegetables that aren't picked by our volunteers are given free of charge to seniors and physically challenged people in the Pleasant Hill neighborhood," Johnson said.
Johnson said that community gardens like the ones in Pleasant Hill and Beall's Hill not only help revitalize the area around them, but they also help people develop better eating habits.
"I had to tell the people helping us not to fry the tomatoes. I don't recommend eating fried green tomatoes. They're not very good for you at all," she said.
But perhaps the best part about neighborhood gardens, in Johnson's opinion, is that they bring people together.
"In the dirt, everybody's kin. And that's just something that money can't put a price tag on," she said.
14 Jun 2009
[box]
Commemorating history
Annual Juneteenth festival celebrates liberation, educates about struggles of slavery.
By Carl Lewis
<EMAIL_ADDRESS>Sunday, Jun. 14, 2009
[/box]
Four years ago, Nduta Mwangi, 39, lived in a small tenement apartment in Kenya, where she and her sisters sewed traditional African dresses for a living.
Saturday, she brought those dresses to Macon and put them on sale at the annual Juneteenth Freedom Festival at Tattnall Square Park.
“These dresses represent who I am and who we as African-Americans are. It’s our living symbolic legacy,” she said.
The festival was a daylong celebration of Juneteenth, the holiday which commemorates the liberation of slaves in Galveston, Texas, on June 19, 1865.
“It’s sort of like an African-American Independence Day,” said Michelle Fitz, a festival organizer.
But Fitz said that Juneteenth isn’t just for African-Americans.
“It’s a way to educate people of all races about the struggles of slavery. So many people have no idea or they forget what our people went through,” she said.
The festival featured live jazz music, arts and crafts vendors and educational presentations.
Festival director George Muhammad said he expected as many as 1,000 people to attend the festival by the end of the day.
Baatin Muhammad, a member of the Middle Georgia Jazz Allstar Band, said the festival is one of the band’s best opportunities to play yet.
“We’re really excited to play at this event in particular because of what it means to us. It means freedom. It means liberty. It means everything jazz music is supposed to be about,” he said.
One of the festival highlights was a Civil War era re-enactment that demonstrated the black freedom struggle.
Clifford Price, who’s been putting on the re-enactment in his spare time for the past 22 years, said his lifelong mission is to teach people to appreciate the hardships faced by black Union soldiers.
“We want to teach people what our ancestors did during the Civil War, about how they gave up their lives for that elusive word called freedom,” Price said.
James Simpson, a 49-year-old from Macon, has been bringing his wife and five kids to the festival for as long as he can remember.
“We come every year with lawn chairs and a cooler of sodas and stay all day. It’s not only fun, but it’s a great way to teach my kids something,” he said.
Simpson said he was particularly impressed with the variety of merchandise being sold at this year’s festival.
“I just got me a brand new yard hat,” he said.
Ankur Patel, a junior at Mercer University, said he heard the music from the festival as he was walking down College Street and decided to see what the event was all about.
“It’s pretty amazing to hear all this history. Even though I’m not black, I can appreciate it. It’s important that we all support events like this that teach people history and will change the way they look at things today,” he said.


The objective of the Sign Language Interpreter Glove (SLIG) project is to create a device that will aid in the communication barrier between vocal and sign language speakers. This project demonstrates the application of a glove equipped with multiple sensors such that it can be worn on a person’s hand and has the ability to recognize the American Sign Language (ASL) signs performed by the user. Whatever sign the glove has recognized will be displayed through the designated user interface (Android Application). The project was chosen with two purposes in mind; the first being to help ASL speakers communicate with those who do not understand ASL and the second to help non-ASL speakers learn and practice signing.
The motivation to pursue this project comes from one of our team members who has experienced the difficulty of communicating with his speech-impaired sister. It is estimated that approximately 1 million people in the United States (0.38% of the population) are deaf. We want our Senior Design Project to help deaf people communicate with their loved ones and our SLIG is just the first step into accomplishing this task.
Boeing Corporate Offices
100 North Riverside
Chicago, Illinois 60606
(312) 544-2000
Leidos, Inc. Corporate Office
11951 Freedom Drive
Reston, VA 20190
(571) 526-6000


{% extends "base_forms.html" %} {% load crispy_forms_tags %} {% block logo %} {% include "includes/logo.html" %} {% endblock %} {% block content %}
Please fill out this form if you are a Carpentries Instructor or affiliated with a Member Organisation to register a self-organised workshop. We use the URL of your workshop website to collect information, so please set that up using our workshop template before filling out this form. However, if you need to use a workshop website that is different from our template, you can still submit it through this form.
If you are not affiliated with a Member Organisation or are a Certified Carpentries Instructor, please use our request a workshop form or request more information about a workshop.
{% crispy form %} {% endblock %}


Genetic Traveller
Number of Cities
10
Population Size
10
Mutation Rate (%)
1
Set It Up!
Speed
12
GitHub
Brute Force
Genetic Algorithm


Table of Contents
Description
This module is a SIMP Puppet profile for setting up common Rsyslog configurations as supported by the SIMP ecosystem
This is a SIMP module
This module is a component of the System Integrity Management Platform, a compliance-management framework built on Puppet.
If you find any issues, they may be submitted to our bug tracker.
This module is optimally designed for use within a larger SIMP ecosystem, but it can be used independently:
-
When included within the SIMP ecosystem, security compliance settings will be managed from the Puppet server.
-
If used independently, all SIMP-managed security subsystems are disabled by default and must be explicitly opted into by administrators. Please review the parameters in simp/simp_options for details.
Setup
What simp_rsyslog affects
This module provides configurations for both Rsyslog local and Rsyslog server configurations.
Usage
Local Logging
To set up local logging, you can simply do the following:
include '::simp_rsyslog'
The $log_collection
Hash
provides an
Rsyslog 7
compatible set of filters that you wish to collect.
These will be considered security relevant and fed into
/var/log/secure
by default.
The Hash
has the following format and all entries will be
combined with a logical OR
.
$log_collection = {
'programs' => [ <logged daemon names> ],
'facilities' => [ <syslog facilities> ],
'priorities' => [ <syslog priorities> ],
'msg_starts' => [ <strings the message starts with> ],
'msg_regex' => [ <regular expression matches> ]
}
If you need something more complex than this, you will need to configure
your own rsyslog rules using the ::rsyslog::rule
defined type.
If you simply want to log EVERYTHING to your remote
servers, set simp_rsyslog::collect_everything
to
true
.
If you do this, it is highly recommended that you set
simp_rsyslog::log_local
to false
so that you
don't overwhelm your filesystem.
NOTE
If you do not capture the local6
syslog facility, you will
lose a lot of SIMP-specific messaging
Centralized Logging
While we highly recommend using ELG for collecting your logs, we understand that this is not practical for all situations.
If you wish to collect logs from remote hosts, you can do the following:
Manifest:
include '::simp_rsyslog'
Hieradata:
---
simp_rsyslog::is_server : true
This will set your system up as an Rsyslog server, using TLS which is capable of collecting both TCP and UDP logs.
At this time, the version of Rsyslog that ships with EL systems cannot handle both TLS and non-TLS TCP connections at the same time. When it can, we will support this mode of log collection.
UDP logs will not be encrypted in transit but are supported for network device compatibility.
Log Forwarding
If you wish to set your system up to forward logs to a set of remote log servers, in either the server or client case, you should use the following:
include '::simp_rsyslog::log_shipper'
This will use the $simp_options::syslog::log_servers
and
$simp_options::syslog::failover_log_servers
variables to set
the targets for your logs. Alternatively, you can specify the targets in
Hiera directly.
TLS and TCP connections will be used for log forwarding for security purposes.
WARNING
Be VERY careful when setting your
simp_rsyslog::log_servers
andsimp_rsyslog::failover_log_servers
Arrays!There is no foolproof way to detect if you are setting your local log server as part of the Array. If you do this, you may end up with infinite log loops that fill your log server's disk space within minutes.
WARNING
Reference
See the API Documentation for full details.
Limitations
This is a SIMP Profile. It will not expose all options of the underlying modules, only the ones that are conducive to a supported SIMP infrastructure. If you need to do things that this module does not cover, you may need to create your own profile or inherit this profile and extend it to meet your needs.
SIMP Puppet modules are generally intended for use on Red Hat Enterprise Linux and compatible distributions, such as CentOS. Please see the metadata.json file for the most up-to-date list of supported operating systems, Puppet versions, and module dependencies.
Development
Please read our Contribution Guide.
Acceptance tests
This module includes Beaker acceptance tests using the SIMP Beaker Helpers. By default the tests use Vagrant with VirtualBox as a back-end; Vagrant and VirtualBox must both be installed to run these tests without modification. To execute the tests run the following:
bundle install
bundle exec rake beaker:suites
Please refer to the SIMP Beaker Helpers documentation for more information.


Whenever the last reference to an object is lost the object becomes garbage---a section of memory that is no longer in use. A part of the Java system called the garbage collector periodically looks through memory for garbage, which it the makes ready for use with new objects.
Write a program that has a loop that iterates 1000 times. The loop body will use a constructor to create a String object. Click here to go back to the main menu.
Write a program that adds up five floating point numbers input from a file (or from the keyboard.) As always with input from text files, use readLine() to get a string of characters. This string must contain only characters that designate a floating point number, like -0.184 or 1.23E+12. Characters that designate an integer, like 412 will also work for floating point input. Recall how to convert a string into a floating point number:
Click here to go back to the main menu.String lineIn; double val; . . . val = ( Double.valueOf( lineIn ) ).doubleValue();
Modify the program that adds five integers so that it first asks if further prompts are desired. The user enters "yes" or "no" (just once, at the beginning). Now the loop either prompts or does not prompt for each of the integers to be input.
You will need to use the equals() method of String. Set a boolean variable to true or false depending on the user's first input string. There will be an if statement inside the loop that determines if a prompt is written.
Click here to go back to the main menu.


Demonstrates using Java Persistence APIs based on the new Java Persistence specification. The EJB interacts with a relational database to store and display information about customer subscriptions to periodicals.


| Home | Libraries | People | FAQ | More |
Run
A Run represents an (offset, end_offset) 2-tuple, which represents a half-open range of numbers.
offset_type
boost::result_of<boost::range_run_storage::op::offset(boost::add_reference<R>::type)>::type
The type of the offset and end_offset values.
length_type
boost::result_of<boost::range_run_storage::op::length(boost::add_reference<R>::type)>::type
The type of the run length; usually an unsigned version of the offset_type, if the offset_type is integral.
is_unit_length
boost::range_run_storage::traits::is_unit_length<R>::type
Either mpl::true_ or mpl::false_ depending on whether or not this Run is indivisible.
| Name | Expression | Type | Semantics |
|---|---|---|---|
Offset |
boost::range_run_storage::offset(r) |
offset_type |
Returns the start offset of the Run. |
End Offset |
boost::range_run_storage::end_offset(r) |
offset_type |
Returns the end offset of the Run. |
Length |
boost::range_run_storage::length(r) |
length_type |
Returns the length of the Run. |
Empty |
boost::range_run_storage::empty(r) |
Convertible to bool |
Returns true if the Run is empty, false otherwise. |
| Copyright © 2006 Eric Niebler |


mach_msg
System Trap / Function - Send and/or receive a message from the target port.
SYNOPSIS
mach_msg_return_t mach_msg (mach_msg_header_t msg, mach_msg_option_t option, mach_msg_size_t send_size, mach_msg_size_t receive_limit, mach_port_t receive_name, mach_msg_timeout_t timeout, mach_port_t notify); mach_msg_return_t mach_msg_overwrite (mach_msg_header_t* send_msg, mach_msg_option_t option, mach_msg_size_t send_size, mach_msg_size_t receive_limit, mach_port_t receive_name, mach_msg_timeout_t timeout, mach_port_t notify, mach_msg_header_t *receive_msg, mach_msg_size_t receive_msg_size);
PARAMETERS
- msg
-
[pointer to in/out structure containing random and reply rights] A
message buffer used by mach_msg both for send and receive. This must
be naturally aligned.
- send_msg
-
[pointer to in structure containing random and reply rights] The mes-
sage buffer to be sent. This must be naturally aligned.
- option
-
[in scalar] Message options are bit values, combined with bitwise-or.
One or both of MACH_SEND_MSG and MACH_RCV_MSG should be used. Other
options act as modifiers.
- send_size
-
[in scalar] When sending a message, specifies the size of the message
buffer to be sent (the size of the header and body) in
bytes. Otherwise zero should be supplied.
- receive_limit
-
[in scalar] When receiving a message, specifies the maximum size of
the msg or receive_msg buffer in bytes. Otherwise zero should be sup-
plied.
- receive_name
-
[in random right] When receiving a message, specifies the port or port
set. Otherwise MACH_PORT_NULL should be supplied.
- timeout
-
[in scalar] When using the MACH_SEND_TIMEOUT and MACH_RCV_TIMEOUT
options, specifies the time in milliseconds to wait before giving
up. Otherwise MACH_MSG_TIMEOUT_NONE should be supplied.
- notify
-
[in notify receive right] When using the MACH_SEND_CANCEL and
MACH_RCV_NOTIFY options, specifies the port used for the
notification. Otherwise MACH_PORT_NULL should be supplied.
- receive_msg
-
[pointer to in/out structure] A message buffer into which a message
(header and body) will be received. This must be naturally aligned. By
default (mach_msg), any received message will overwrite the send
message buffer. This buffer is in/out only if the MACH_RCV_OVERWRITE
option is used; otherwise this buffer is out only.
- receive_msg_size
- [in scalar] When using the MACH_RCV_OVERWRITE option, specifies the size (in bytes) of the receive "message" that is to be used by mach_msg to indicate the disposition of received out-of-line regions.
DESCRIPTION
The mach_msg system call sends and receives Mach messages. Mach messages contain data, which can include port rights and addresses of large regions of memory. mach_msg uses the same buffer for sending and receiving a message; the other calls permit separate send and receive buffers (although they may be specified to be the same). If the option argument contains MACH_SEND_MSG, the call sends a message. The send_size argument specifies the size of the message buffer (header and body) to send. The msgh_remote_port field of the message header specifies the destination of the message. If the option argument contains MACH_RCV_MSG, it receives a message. The receive_limit argument specifies the size of a buffer that will receive the message; messages that are larger are not received. The receive_name argument specifies the port or port set from which to receive.
If the option argument contains both MACH_SEND_MSG and MACH_RCV_MSG, then mach_msg does both send and receive operations (in that order). If the send operation encounters an error (any return code other than MACH_MSG_SUCCESS), the call returns immediately without attempting the receive operation. Semantically the combined call is equivalent to separate send and receive calls, but it saves a system call and enables other internal optimizations. If the option argument specifies neither MACH_SEND_MSG nor MACH_RCV_MSG, mach_msg does nothing. Some options, like MACH_SEND_TIMEOUT and MACH_RCV_TIMEOUT, share a supporting argument. If these options are used together, they make independent use of the supporting argument's value.
NOTES
The Mach kernel provides message-oriented, capability-based inter-process communication. The inter-process communication (IPC) primitives efficiently support many different styles of interaction, including remote procedure calls, object-oriented distributed programming, streaming of data, and sending very large amounts of data.
Major Concepts
The IPC primitives operate on three abstractions: messages, ports, and port sets. User tasks access all other kernel services and abstractions via the IPC primitives.
The message primitives let tasks send and receive messages. Tasks send messages to ports. Messages sent to a port are delivered reliably (messages may not be lost) and are received in the order in which they were sent via send rights by a given sending task (or a given kernel). (Messages sent to send-once rights are unordered.)
Messages contain a fixed-size header and a variable-sized message body containing kernel and user data, and a variable-size trailer of kernel appended message attributes. The header describes the destination and the size of the message (header plus body). The message body contains descriptions of additional port rights to be transmitted, descriptions of "out-of-line" memory regions to be sent and a variable amount of user data, which typically includes type conversion information. The out-of-line memory regions (including out-of-line port arrays) are (typically) disjoint from the message body. The IPC implementation makes use of the VM system to efficiently transfer large amounts of data. The message can contain the addresses of regions of the sender's address space which should be transferred as part of the message.
When a task receives a message containing such out-of-line regions of data, the data can appear in unused portions or overwrite an existing portion of the receiver's address space (depending on the requested receive options). Under favorable circumstances, the transmission of out-of-line data is optimized so that sender and receiver share the physical pages of data copy-on-write, and no actual data copy occurs unless the pages are written. Regions of memory up to 4 gigabytes may be sent in this manner.
Ports hold a queue of messages. Tasks operate on a port to send and receive messages by exercising capabilities (rights) for the port. Multiple tasks can hold send rights for a port. Tasks can also hold send-once rights, which grant the ability to send a single message. Only one task can hold the receive capability (receive right) for a port.
Port rights can be transferred between tasks via messages. The sender of a message can specify in the message that the message contains a port right. If a message contains a receive right for a port, the receive right is removed from the sender of the message and transferred to the receiver of the message. While the receive right is in transit, tasks holding send rights can still send messages to the port, and they are queued until a task acquires the receive right and uses it to receive the messages.
Tasks can receive messages from ports and port sets. The port set abstraction allows a single thread to wait for a message from any of several ports. Tasks manipulate port sets with a port set name, which is taken from the same name space as are the port rights. The port-set name may not be transferred in a message. A port set holds receive rights, and a receive operation on a port set blocks waiting for a message sent to any of the constituent ports. A port may not be- long to more than one port set, and if a port is a member of a port set, the holder of the receive right can't receive directly from the port.
Port rights are a secure, location-independent way of naming ports. The port queue is a protected data structure, only accessible via the kernel's exported message primitives. Rights are also protected by the kernel; there is no way for a malicious user task to guess a port's internal name and send a message to a port to which it shouldn't have access. Port rights do not carry any location in- formation. When a receive right for a port moves from task to task, and even between tasks on different machines, the send rights for the port remain unchanged and continue to function.
Port Rights
Each task has its own space of port rights. Port rights are named with positive (unsigned) integers. For all architectures, sizeof (mach_port_t) = sizeof (mach_port_name_t) = sizeof (void*) and so user space addresses may be used as port names, except for the reserved values MACH_PORT_NULL (0) and MACH_PORT_DEAD (all 1 bits). When the kernel chooses a name for a new right, however, it is free to pick any unused name (one which denotes no right) in the space.
There are three basic kinds of rights: receive rights, send rights and send-once rights. A port name can name any of these types of rights, or name a port-set, be a dead name, or name nothing. Dead names are not capabilities. They act as place-holders to prevent a name from being otherwise used.
A port is destroyed, or dies, when its receive right is de-allocated. When a port dies, send and send-once rights for the port turn into dead names. Any messages queued at the port are destroyed, which de-allocates the port rights and out-of-line memory in the messages.
Each send-once right held by a task has a different name. In contrast, when a task holds send rights or a receive right for a port, the rights share a single name.
Tasks may hold multiple user-references for send rights. When a task receives a send right which it already holds, the kernel increments the right's user-reference count. When a task de-allocates a send right, the kernel decrements its user-reference count, and the task only loses the send right when the count goes to zero.
Send-once rights always have a user reference count of one. Tasks may hold multiple user references for dead names. Each send-once right generated guarantees the receipt of a single message, either a message sent to that send-once right or, if the send-once right is in any way destroyed, a send-once notification.
A message can carry port rights; the msgh_remote or msgh_local fields in the message header or the disposition field in a message body descriptor specify the type of port right and how the port right is to be extracted from the caller. The values MACH_PORT_NULL and MACH_PORT_DEAD are valid in place of a port right in a message body.
In a sent message, the following mach_msg_type_name_t values denote port rights:
- MACH_MSG_TYPE_MAKE_SEND
- The message will carry a send right, but the caller must supply a receive right. The send right is created from the receive right, and the receive right's make-send count is incremented.
- MACH_MSG_TYPE_COPY_SEND
- The message will carry a send right, and the caller must supply a send right. The user reference count for the supplied send right is not changed. The caller may also supply a dead name and the receiving task will get MACH_PORT_DEAD.
- MACH_MSG_TYPE_MOVE_SEND
- The message will carry a send right, and the caller must supply a send right. The user reference count for the supplied send right is decremented, and the right is destroyed if the count becomes zero. Unless a receive right remains, the name becomes available for recycling. The caller may also supply a dead name, which loses a user reference, and the receiving task will get MACH_PORT_DEAD.
- MACH_MSG_TYPE_MAKE_SEND_ONCE
- The message will carry a send-once right, but the caller must supply a receive right. The send-once right is created from the receive right. Note that send once rights can only be created from the receive right.
- MACH_MSG_TYPE_MOVE_SEND_ONCE
- The message will carry a send-once right, and the caller must supply a send-once right. The caller loses the supplied send-once right. The caller may also supply a dead name, which loses a user reference, and the receiving task will get MACH_PORT_DEAD.
- MACH_MSG_TYPE_MOVE_RECEIVE
- The message will carry a receive right, and the caller must supply a receive right. The caller loses the supplied receive right, but retains any send rights with the same name. The make-send count and sequence number of the receive right are reset to zero and no-more-senders notification requests are cancelled (with a send-once notification being sent to the no-more-senders notification right), but the port retains other attributes like queued messages and extant send and send-once rights. If a message carries a send or send-once right, and the port dies while the message is in transit, then the receiving task will get MACH_PORT_DEAD instead of a right.
The following mach_msg_type_name_t values in a received message indicate that it carries port rights:
- MACH_MSG_TYPE_PORT_SEND
- This value is an alias for MACH_MSG_TYPE_MOVE_SEND. The message carried a send right. If the receiving task already has send and/ or receive rights for the port, then that name for the port will be reused. Otherwise, the right will have a new, previously unused, name. If the task already has send rights, it gains a user reference for the right (un- less this would cause the user-reference count to overflow). Otherwise, it acquires send rights, with a user-reference count of one.
- MACH_MSG_TYPE_PORT_SEND_ONCE
- This value is an alias for MACH_MSG_TYPE_MOVE_SEND_ONCE. The message carried a send-once right. The right will have a new, previously unused, name.
- MACH_MSG_TYPE_PORT_RECEIVE
- This value is an alias for MACH_MSG_TYPE_MOVE_RECEIVE. The message carried a receive right. If the receiving task already has send rights for the port, then that name for the port will be reused; otherwise, the right will have a new, previously unused name.
It is also possible to send a (nearly unbounded) array of port rights "out-of-line". All of the rights named by the array must be of the same type. The array is physically copied with the message body proper. The array of port right (names) can be received by the receiver using the same options available for out-of-line data reception described below.
Memory
A message can contain one or more regions of the sender's address space which are to be transferred as part of the message. The message carries a logical copy of the memory. For this "out-of-line" memory, the kernel can copy the data or use virtual memory techniques to defer any actual page copies unless the sender or the receiver modifies the data, the physical pages remain shared.
The sender of the message must explicitly request an out-of-line transfer. Such a region is described as an arbitrary region of the sender's address space. The sender always sees this memory as being copied to the receiver.
For each region, the sender has a de-allocate option. If the option is set and the out-of-line memory region is not null, then the region is implicitly de-allocated from the sender, as if by vm_deallocate. In particular, the start address is truncated down and the end address rounded up so that every page overlapped by the memory region is de-allocated (thereby possibly de-allocating more memory than is effectively transmitted). The use of this option effectively changes the memory copy to a memory movement. Aside from possibly optimizing the sender's use of memory, the de-allocation option allows the kernel to more efficiently handle the transfer of memory.
For each region, the sender has the choice of permitting the kernel to choose a transmission strategy or the choice of requiring physical copy:
- MACH_MSG_VIRTUAL_COPY
-
In a sent message, this flag allows the kernel to choose any mechanism
to transmit the data. For large regions, this involves constructing a
virtual copy of the pages containing the region. The portion of the
first page preceding the data and the portion of the last page
following the data are not copied (and will appear as zero if the
virtual copy is dynamically allocated in the receiver).
In a received message, this flag indicates that the kernel transmitted a virtual copy. Access to the received memory may involve interactions with the memory manager managing the sender's original data. Integri- ty-conscious receivers should exercise caution when dealing with out- of-line memory from un-trustworthy sources. Receivers concerned about deterministic access time should also exercise caution. The dynamic allocation option guarantees that the virtual copy will not be di- rectly referenced during the act of receiving the message.
- MACH_MSG_PHYSICAL_COPY
-
In a sent message, this flag requires that the kernel construct an
actual copy of the memory (either into wired kernel memory or default
memory managed space). There is a (fairly large) limit on the amount
of data that can be physically copied in a message. Port arrays always
assume this option when sent.
In a received message, this flag indicates that the kernel did transmit a physical copy.
The receiver has two options for the reception of out-of-line memory (or "out-of-line" port arrays): allocation and overwrite. In the absence of the MACH_RCV_OVERWRITE option, all out-of-line re- gions are dynamically allocated. Allocated out-of-line memory arrives somewhere in the receiver's address space as new memory. It has the same inheritance and protection attributes as newly vm_allocate'ed memory. The receiver has the responsibility of de-allocating (with vm_deallocate) the memory when it is no longer needed. If the message contains more than one region, each will be allocated its own region, not necessarily contiguously. If the sender's data was transmitted as a virtual copy the allocated region will have the same data alignment within the page; otherwise, the received data will appear starting at the beginning of a page.
If the MACH_RCV_OVERWRITE option is set, the receiver can specify how each received region is to be processed (dynamically allocated as described above, or written over existing memory). With this option, the contents of the receive buffer (receive_msg) are examined by the kernel. The kernel scans the descriptors in the receive buffer "message" to determine how to handle each out-of-line region. (Note: whereas receive_limit is the maximum size of the receive buffer, receive_msg_size is the amount filled in with this "message".) The kernel uses each out-of-line data descriptor (in order) to specify the processing for each received data region in turn, each out-of-line port array descriptor is used correspondingly. (Intermingled port descriptors are ignored when matching descriptors between the incoming message and the receive buffer list.)
The copy option in the matching descriptor specifies the processing:
- MACH_MSG_OVERWRITE
- This flag indicates that the region should write over a specified region of the receiver's address space, as indicated by the address and size/ count fields of the descriptor. The full range overwritten must already exist (be allocated or mapped) in the receiver's address space. Depending on the nature of the data transmission this overwrite may involve virtual memory manipulations or it may involve actual data copy.
- MACH_MSG_ALLOCATE
- This flag indicates that the region is to be dynamically allocated. No other descriptor values are relevant.
If not enough descriptors appear in the receive buffer to describe all received regions, additional regions are dynamically allocated. If the receiver specifies more descriptors than there are regions in the received message, the additional descriptors are ignored (and do not appear in the final received message).
Note that the receive buffer descriptors will be overwritten: The size fields in descriptors will be updated (when scanned, they specified the maximum sizes of regions, when received, they specify the actual sizes of received regions). The copy fields in descriptors will be updated (when scanned, they specified allocate versus overwrite, when received, they indicate whether the region was physically or virtually copied). The descriptors may appear in different positions (given intermingled port descriptors). Descriptors that were not used (because there were not that many received regions) will be discarded.
Null out-of-line memory is legal. If the out-of-line region size is zero, then the region's specified address is ignored. A receive allocated null out-of-line memory region always has a zero address. Unaligned addresses and region sizes that are not page multiples are legal. A received message can also contain regions with unaligned addresses and sizes which are not multiples of the page size.
Message Send
The send operation queues a message to a port. The message carries a copy of the caller's data. After the send, the caller can freely modify the message buffer or the out-of-line memory regions and the message contents will remain unchanged.
The message carries with it the security ID of the sender, which the receiver can request in the message trailer.
Message delivery is reliable and sequenced. Reception of a message guarantees that all messages previously sent to the port by a single task (or a single kernel) via send rights have been received and that they are received in the order in which they were sent. Messages sent to send-once rights are unordered.
If the destination port's queue is full, several things can happen. If the message is sent to a send-once right (msgh_remote_port carries a send-once right), then the kernel ignores the queue limit and delivers the message. Otherwise the caller blocks until there is room in the queue, unless the MACH_SEND_TIMEOUT option is used. If a port has several blocked senders, then any of them may queue the next message when space in the queue becomes available, with the proviso that a blocked sender will not be indefinitely starved. These options modify MACH_SEND_MSG. If MACH_SEND_MSG is not also specified, they are ignored.
- MACH_SEND_TIMEOUT
- The timeout argument should specify a maximum time (in milliseconds) for the call to block before giving up. If the message can't be queued before the timeout interval elapses, then the call returns MACH_SEND_TIMED_OUT. A zero timeout is legitimate.
- MACH_SEND_INTERRUPT
- If specified, the mach_msg call will return MACH_SEND_INTERRUPTED if a software interrupt aborts the call. Otherwise, the send operation will be retried.
- MACH_SEND_TRAILER
- If set, the kernel, instead of determining the message attributes itself, will accept a formatted message trailer from the sender. The supplied trailer must be of the latest version supported by the kernel, and must contain all message attributes defined by the kernel. Only tasks with a security ID of KERNEL_SECURITY_ID can use this option; the intended use of this option is in support of the Net Message server. The trailer must follow the message in memory as it would appear in a received message. (The send_size argument to mach_msg still indicates the size of the message proper, not including this trailer.)
The queueing of a message carrying receive rights may create a circular loop of receive rights and messages, which can never be received. For example, a message carrying a receive right can be sent to that receive right. This situation is not an error, but the kernel will garbage-collect such loops, destroying the messages. Some return codes, like MACH_SEND_TIMED_OUT, imply that the message was almost sent, but could not be queued. In these situations, the kernel tries to return the message contents to the caller with a pseudo-receive operation. This prevents the loss of port rights or memory which only exist in the message, for example, a receive right which was moved into the message, or out-of-line memory sent with the de-allocate option.
The intent of the pseudo-receive operation is to restore, as best as possible, the state prior to attempting the send. This involves restoring the port rights and out-of-line memory regions contained in the message. The port right names and out-of-line addresses in the message send buffer are updated to reflect the new values resulting from their effective reception. The pseudo-receive handles the des- tination and reply rights as any other rights; they are not reversed as is the appearance in a normal received message. Also, no trailer is appended to the message. After the pseudo-receive, the message is ready to be resent. If the message is not resent, note that out-of-line memory regions may have moved and some port rights may have changed names.
Although unlikely, the pseudo-receive operation may encounter resource shortages. This is similar to a MACH_RCV_BODY_ERROR return code from a receive operation. When this happens, the normal send return codes are augmented with the MACH_MSG_IPC_SPACE, MACH_MSG_VM_SPACE, MACH_MSG_IPC_KERNEL and MACH_MSG_VM_KERNEL bits to indicate the nature of the resource shortage.
Message Receive
The receive operation de-queues a message from a port. The receiving task acquires the port rights and out-of-line memory regions carried in the message. The receive_name argument specifies a port or port set from which to receive. If a port is specified, the caller must possess the receive right for the port and the port must not be a member of a port set. If no message is present, the call blocks, subject to the MACH_RCV_TIMEOUT option.
If a port set is specified, the call will receive a message sent to any of the member ports. It is permissible for the port set to have no member ports, and ports may be added and removed while a receive from the port set is in progress. The received message can come from any of the member ports which have messages, with the proviso that a member port with messages will not be indefinitely starved. The msgh_local_port field in the received message header specifies from which port in the port set the message came.
The receive_limit argument specifies the size of the caller's message buffer (which must be big enough for the message header, body and trailer); the msgh_size field of the received message indicates the actual size of the received message header and body. The mach_msg call will not receive a message larger than receive_limit. Messages that are too large are destroyed, unless the MACH_RCV_LARGE option is used. Following the received data, at the next natural boundary, is a message trailer. The msgh_size field of the received message does not include the length of this trailer; the trailer's length is given by the msgh_trailer_size field within the trailer. The receiver of a message is given a choice as to what trailer format is desired, and, within that format, which of the leading trailer attributes are desired (that is, to get trailer element three, the receiver must also accept elements one and two). For any given trailer format (of which there is currently only one), the trailer is compatibly extended by adding additional elements to the end.
Received messages are stamped (in the trailer) with a sequence number, taken from the port from which the message was received. (Messages received from a port set are stamped with a sequence number from the appropriate member port.) Newly created ports start with a zero sequence number, and the sequence number is reset to zero whenever the port's receive right moves between tasks. When a message is de-queued from the port, it is stamped with the port's sequence number and the port's sequence number is then incremented. (Note that this occurs whether or not the receiver requests the sequence number in the trail- er.) The de-queue and increment operations are atomic, so that multiple threads receiving messages from a port can use the msgh_seqno field to reconstruct the original order of the messages.
The destination and reply ports are reversed in a received message header. The msgh_local_port field carries the name of the destination port, from which the message was received, and the msgh_remote_port field carries the reply port right. The bits in msgh_bits are also reversed. The MACH_MSGH_BITS_LOCAL bits have a value of MACH_MSG_TYPE_PORT_SEND_ONCE or MACH_MSG_TYPE_PORT_SEND depending on the type of right to which the message was sent. The MACH_MSGH_BITS_REMOTE bits describe the reply port right.
A received message can contain port rights and out-of-line memory. The msgh_local_port field does not carry a port right; the act of receiving the message consumes the send or send-once right for the destination port. The msgh_remote_port field does carry a port right, and the message can carry additional port rights and memory if the MACH_MSGH_BITS_COMPLEX bit is set. Received port rights and memory should be consumed or de-allocated in some fashion. In almost all cases, msgh_local_port will specify the name of a receive right, either receive_name, or, if receive_name is a port set, a member of receive_name.
If other threads are concurrently manipulating the receive right, the situation is more complicated. If the receive right is renamed during the call, then msgh_local_port specifies the right's new name. If the caller loses the receive right after the message was de-queued from it, then mach_msg will proceed instead of returning MACH_RCV_PORT_DIED. If the receive right was destroyed, then msgh_local_port specifies MACH_PORT_DEAD. If the receive right still exists, but isn't held by the caller, then msgh_local_port specifies MACH_PORT_NULL.
The following options modify MACH_RCV_MSG. If MACH_RCV_MSG is not also specified, they are ignored.
- MACH_RCV_TIMEOUT
- The timeout argument should specify a maximum time (in milliseconds) for the call to block before giving up. If no message arrives before the timeout interval elapses, then the call returns MACH_RCV_TIMED_OUT. A zero timeout is legitimate.
- MACH_RCV_NOTIFY
- The notify argument should specify a receive right for a notify port. If receiving the reply port creates a new port right in the caller, then the notify port is used to request a dead-name notification for the new port right.
- MACH_RCV_INTERRUPT
- If specified, the mach_msg call will return MACH_RCV_INTERRUPTED if a software interrupt aborts the call. Otherwise, the receive operation will be retried.
- MACH_RCV_OVERWRITE
- If specified, the message buffer specified by receive_msg (or msg), of length receive_msg_size, will be scanned for out-of-line descriptors to specify the processing to be done when receiving out-of-line regions. This option is only allowed for mach_msg_overwrite.
- MACH_RCV_LARGE
- If the message is larger than receive_limit or an out-of-line region is larger than the size allowed by a corresponding receive descriptor (MACH_RCV_OVERWRITE), the message remains queued instead of being destroyed. If the header, trailer and body would not fit into receive_limit, only the message header (mach_msg_header) and trailer header (mach_msg_trailer) are returned with the actual size of the message returned in the msgh_size field, the actual size of the trailer returned in the msgh_trailer_size field and an error return value of MACH_RCV_TOO_LARGE. If receive_limit is sufficient but an out-of-line descriptor is not, the message header, trailer and body are received, with out-of-line descriptors set to indicate the nature and size of the out-of-line regions, with an error return of MACH_RCV_SCATTER_SMALL. No out-of-line regions or port rights (including the reply right) will be received. If this option is not specified, messages too large will be de-queued and then destroyed; the caller receives the message header, with all fields correct, including the destination port but excepting the reply port, which is MACH_PORT_NULL and an empty (no additional element) message trailer.
- MACH_RCV_TRAILER_TYPE(value)
- This macro encodes the type of trailer the kernel must return with the message. If the kernel does not recognize this type, it returns MACH_RCV_INVALID_TRAILER. Currently, only MACH_MSG_TRAILER_FORMAT_0 is supported.
- MACH_RCV_TRAILER_ELEMENTS(value)
- This macro encodes the number of trailer elements desired. If the ker- nel does not support this number for the requested trailer type, the kernel returns MACH_RCV_INVALID_TRAILER. Zero is a legal value.
The following trailer elements are supported:
- MACH_RCV_TRAILER_SEQNO
- Returns the sequence number of the message relative to its port. This value is of type mach_port_seqno_t.
- MACH_RCV_TRAILER_SENDER
- Returns the security ID of the task that sent the message. This value is of type security_id_t.
If a resource shortage prevents the reception of a port right, the port right is destroyed and the caller sees the name MACH_PORT_NULL. If a resource shortage prevents the reception of an out-of-line memory region, the region is destroyed and the caller sees a zero address. In addition, the corresponding element in the size array is set to zero. A task never receives port rights or memory for which it is not told.
The MACH_RCV_HEADER_ERROR return code indicates a resource shortage in the reception of the message header. The reply port and all port rights and memory in the message are destroyed. The caller receives the message header with all fields correct except for the reply port.
The MACH_RCV_BODY_ERROR return code indicates a resource shortage in the reception of the message body. The message header, including the reply port, is correct. The kernel attempts to transfer all port rights and memory regions in the body, and only destroys those that can't be transferred.
Atomicity
The mach_msg call handles port rights in the message header atomically. Out-of-line memory and port rights in the message body do not enjoy this atomicity guarantee. These elements may be processed front-to-back, back-to-front, in some random order, or even atomically.
For example, consider sending a message with the destination port specified as MACH_MSG_TYPE_MOVE_SEND and the reply port specified as MACH_MSG_TYPE_COPY_SEND. The same send right, with one user-refer- ence, is supplied for both the msgh_remote_port and msgh_local_port fields. Because mach_msg processes the port rights atomically, this succeeds. If msgh_remote_port were processed before msgh_local_port, then mach_msg would return MACH_SEND_INVALID_REPLY in this situation.
On the other hand, suppose the destination and reply port are both specified as MACH_MSG_TYPE_MOVE_SEND, and again the same send right with one user-reference is supplied for both. Now the send operation fails, but because it processes the rights atomically, mach_msg can return either MACH_SEND_INVALID_DEST or MACH_SEND_INVALID_REPLY.
For example, consider receiving a message at the same time another thread is deallocating the destination receive right. Suppose the reply port field carries a send right for the destination port. If the de-allocation happens before the dequeuing, the receiver gets MACH_RCV_PORT_DIED. If the de-allocation happens after the receive, the msgh_local_port and the msgh_remote_port fields both specify the same right, which becomes a dead name when the receive right is de-allocated. If the de-allocation happens between the de-queue and the receive, the msgh_local_port and msgh_remote_port fields both specify MACH_PORT_DEAD. Because the rights are processed atomically, it is not possible for just one of the two fields to hold MACH_PORT_DEAD.
The MACH_RCV_NOTIFY option provides a more likely example. Suppose a message carrying a send-once right reply port is received with MACH_RCV_NOTIFY at the same time the reply port is destroyed. If the reply port is destroyed first, then msgh_remote_port specifies MACH_PORT_DEAD and the kernel does not generate a dead-name notification. If the reply port is destroyed after it is received, then msgh_remote_port specifies a dead name for which the kernel generates a dead-name notification. Either the reply port is dead on arrival or notification is requested.
Implementation
mach_msg and mach_msg_overwrite are wrappers for a system call. They have the responsibility for repeating the interrupted system call.
CAUTIONS
If MACH_RCV_TIMEOUT is used without MACH_RCV_INTERRUPT, then the timeout duration might not be accurate. When the call is interrupted and automatically retried, the original timeout is used. If interrupts occur frequently enough, the timeout interval might never expire. MACH_SEND_TIMEOUT without MACH_SEND_INTERRUPT suffers from the same problem.
RETURN VALUES
The send operation can generate the following return codes. These return codes imply that the call did nothing:
- MACH_SEND_MSG_TOO_SMALL
-
The specified send_size was smaller than the minimum size for a
message.
- MACH_SEND_NO_BUFFER
-
A resource shortage prevented the kernel from allocating a message
buffer.
- MACH_SEND_INVALID_DATA
-
The supplied message buffer was not readable.
- MACH_SEND_INVALID_HEADER
-
The msgh_bits value was invalid.
- MACH_SEND_INVALID_DEST
-
The msgh_remote_port value was invalid.
- MACH_SEND_INVALID_NOTIFY
-
When using MACH_SEND_CANCEL, the notify argument did not
denote a valid receive right.
- MACH_SEND_INVALID_REPLY
-
The msgh_local_port value was invalid.
- MACH_SEND_INVALID_TRAILER
- The trailer to be sent does not correspond to the current kernel format, or the sending task does not have the privilege to supply the message attributes.
These return codes imply that some or all of the message was destroyed:
- MACH_SEND_INVALID_MEMORY
-
The message body specified out-of-line data that was not readable.
- MACH_SEND_INVALID_RIGHT
-
The message body specified a port right which the caller didn't possess.
- MACH_SEND_INVALID_TYPE
-
A kernel processed descriptor was invalid.
- MACH_SEND_MSG_TOO_SMALL
- The last data item in the message ran over the end of the message.
These return codes imply that the message was returned to the caller with a pseudo-receive operation:
- MACH_SEND_TIMED_OUT
-
The timeout interval expired.
- MACH_SEND_INTERRUPTED
- A software interrupt occurred.
This return code implies that the message was queued:
- MACH_MSG_SUCCESS
- The message was queued.
The receive operation can generate the following return codes. These return codes imply that the call did not de-queue a message:
- MACH_RCV_INVALID_NAME
-
The specified receive_name was invalid.
- MACH_RCV_IN_SET
-
The specified port was a member of a port set.
- MACH_RCV_TIMED_OUT
-
The timeout interval expired.
- MACH_RCV_INTERRUPTED
-
A software interrupt occurred.
- MACH_RCV_PORT_DIED
-
The caller lost the rights specified by receive_name.
- MACH_RCV_PORT_CHANGED
-
receive_name specified a receive right which was moved into a port set
during the call.
- MACH_RCV_TOO_LARGE
-
When using MACH_RCV_LARGE, the message was larger than
receive_limit. The message is left queued, and its actual size is
returned in the message header/message body.
- MACH_RCV_SCATTER_SMALL
-
When using MACH_RCV_LARGE with MACH_RCV_OVERWRITE, one or more scatter
list descriptors specified an overwrite region smaller than the
corresponding incoming region. The message is left queued, and the
proper descriptors are returned in the message header/message body.
- MACH_RCV_INVALID_TRAILER
- The trailer type desired, or the number of trailer elements desired, is not supported by the kernel.
These return codes imply that a message was de-queued and destroyed:
- MACH_RCV_HEADER_ERROR
-
A resource shortage prevented the reception of the port rights in the
message header.
- MACH_RCV_INVALID_NOTIFY
-
When using MACH_RCV_NOTIFY, the notify argument did not denote a
valid receive right.
- MACH_RCV_INVALID_DATA
-
The specified message buffer was not writable.
- MACH_RCV_TOO_LARGE
-
When not using MACH_RCV_LARGE, a message larger than
receive_limit was de-queued and destroyed.
- MACH_RCV_SCATTER_SMALL
-
When not using MACH_RCV_LARGE with MACH_RCV_OVERWRITE, one or more
scatter list descriptors specified an overwrite region smaller than
the corresponding incoming region. The message was de-queued and
destroyed.
- MACH_RCV_OVERWRITE_ERROR
-
A region specified by a receive overwrite descriptor
(MACH_RCV_OVERWRITE) was not allocated or could not be written.
- MACH_RCV_INVALID_TYPE
-
When using MACH_RCV_OVERWRITE, one or more scatter list descriptors
did not have the type matching the corresponding incoming message
descriptor or had an invalid copy (disposition) field.
- MACH_RCV_LIMITS
-
The combined size of all out-of-line memory regions or the total num-
ber of port rights in the message exceeds the limit set for the port.
These return codes imply that a message was received:
- MACH_RCV_BODY_ERROR
-
A resource shortage prevented the reception of a port right or out-of-
line memory region in the message body.
- MACH_MSG_SUCCESS
- A message was received.
Resource shortages can occur after a message is de-queued, while transferring port rights and out-of-line memory regions to the receiving task. The mach_msg call returns MACH_RCV_HEADER_ERROR or MACH_RCV_BODY_ERROR in this situation. These return codes always carry extra bits (bitwise-or'ed) that indicate the nature of the resource shortage:
- MACH_MSG_IPC_SPACE
-
There was no room in the task's IPC name space for another port name.
- MACH_MSG_VM_SPACE
-
There was no room in the task's VM address space for an out-of-line
memory region.
- MACH_MSG_IPC_KERNEL
-
A kernel resource shortage prevented the reception of a port right.
- MACH_MSG_VM_KERNEL
- A kernel resource shortage prevented the reception of an out-of-line memory region.
RELATED INFORMATION
Functions: vm_allocate, vm_deallocate, vm_write, mach_port_request_notification,
Data Structures: mach_msg_header.


How's it Growing?
A simple app for the home gardener and botanist to keep all of their plants happy and healthy. Log in below and start creating your watering schedule
Email
Password
Log in or Sign up


A drawbar and tonewheel organ simulator.
- 1 (16') ... 9 (1')
- The classic nine drawbars, each with their pitch setting. Each drawbar corresponds to one harmonic. The drawbar amplitude can be set to a value from 0.0 to 8.0.
- 10 and 11
- The common two additional drawbars, corresponding to two harmonics each. The drawbar amplitude can be set to a value from 0.0 to 8.0.
- Perc Decay
- The decay setting for percussion.
- Perc Volume
- The volume setting for percussion.
- Percussion
- Off, or either of the two standard settings ("1st" and "2nd").
- Tuning
- Classic tuning found on drawbar organs, Equal Temperment tuning to which the classic tuning was an approximation, and true harmonic tuning (integer hrmonics).
- Presets...
- A set of presets for classic settings of the first nine drawbars. Choosing a preset will set the drawbars accordingly.


Account overview
0.00
USDWallets Overview
Most Invested
54,825.42 €
BTCTransactions List
- WEEK
- MONTH
- YEAR
| Date | Description | To/From | Amount | Status | ||
|---|---|---|---|---|---|---|
| 28 JUN 2018, 17:21 | Payment to OX LLC | E9873HJKDFJSFHA | 0.061BTC ($445) | Pending | chevron_right | |
|
||||||
| 28 MAR 2018, 18:22 | Payment to OX LLC | E9873HJKDFAWRZ | 0.061BTC ($455) | Confirmed | chevron_right | |
|
||||||
| 28 JAN 2018, 14:59 | Payment to OX LLC | E9873HJKDFFIKGQ | 0.061BTC ($423) | Confirmed | chevron_right | |
|
||||||
| 24 DEC 2017, 14:41 | Payment to OX LLC | E9873HJKDFPWRE | 0.061BTC ($411) | Confirmed | chevron_right | |
|
||||||
| 21 DEC 2017, 15:43 | Payment to OX LLC | E9873HJKDFHFDE | 0.061BTC ($445) | Confirmed | chevron_right | |
|
||||||
| 20 DEC 2017, 13:47 | Payment to OX LLC | E9873HJKDFMFGV | 0.061BTC ($478) | Rejected | chevron_right | |
|
||||||
| 28 NOV 2017, 11:31 | Payment to OX LLC | E9873HJKDFWMSO | 0.061BTC ($445) | Confirmed | chevron_right | |
|


Trading_SellerPaymentPreferencesType Class Reference
| Inherits from | NSObject |
| Conforms to | PicoBindable |
| Declared in | Trading_SellerPaymentPreferencesType.h Trading_SellerPaymentPreferencesType.m |
Overview
Type defining the SellerPaymentPreferences container, which
consists of the seller’s payment preferences. Payment preferences specified in a
SetUserPreferences call override the settings in My eBay payment
preferences.
@ingroup EBayAPIInterface
Tasks
-
alwaysUseThisPaymentAddress
Sellers include this field and set it to ‘true’ if they want buyers to mail payment
property
to the payment address specified in the
SellerPaymentPreferences.SellerPaymentAddress field. A payment
address only comes into play if the item’s category allows offline payments, and the
seller has allowed the buyer to mail a payment. This payment address will only be
displayed to winning bidders and buyers. -
displayPayNowButton
If set, this field determines whether a Pay Now button is displayed for all of the
property
user’s listings. The user has the option of using a PayPal only version of the Pay
Now button or a Pay Now button for all payment methods. -
payPalPreferred
Specifies whether a seller wants to let buyers know that PayPal payments
property
are preferred. -
defaultPayPalEmailAddress
Specifies the default email address the seller uses for receiving PayPal payments.
property -
payPalAlwaysOn
Indicates whether PayPal is always accepted for the seller’s listings.
property -
sellerPaymentAddress
Specifies the address the seller uses to receive mailed payments from buyers.
property -
upsRateOption
Specifies the type of United Parcel Service rates to use.
property -
fedExRateOption
Specifies the type of FedEx rates to use.
property -
uspsRateOption
Specifies the type of USPS rates to use.
property -
any
(public property)
property
Properties
alwaysUseThisPaymentAddress
Sellers include this field and set it to ‘true’ if they want buyers to mail payment
to the payment address specified in the
SellerPaymentPreferences.SellerPaymentAddress field. A payment
address only comes into play if the item’s category allows offline payments, and the
seller has allowed the buyer to mail a payment. This payment address will only be
displayed to winning bidders and buyers.
@property (nonatomic, retain) NSNumber *alwaysUseThisPaymentAddress
Discussion
Sellers include this field and set it to ‘true’ if they want buyers to mail payment
to the payment address specified in the
SellerPaymentPreferences.SellerPaymentAddress field. A payment
address only comes into play if the item’s category allows offline payments, and the
seller has allowed the buyer to mail a payment. This payment address will only be
displayed to winning bidders and buyers.
type : NSNumber, wrapper for primitive bool
Declared In
Trading_SellerPaymentPreferencesType.h
any
(public property)
@property (nonatomic, retain) NSMutableArray *any
Discussion
(public property)
entry type : PicoAnyElement, wrapper for primitive anyelement
Declared In
Trading_SellerPaymentPreferencesType.h
defaultPayPalEmailAddress
Specifies the default email address the seller uses for receiving PayPal payments.
@property (nonatomic, retain) NSString *defaultPayPalEmailAddress
Discussion
Specifies the default email address the seller uses for receiving PayPal payments.
type : NSString, wrapper for primitive string
Declared In
Trading_SellerPaymentPreferencesType.h
displayPayNowButton
If set, this field determines whether a Pay Now button is displayed for all of the
user’s listings. The user has the option of using a PayPal only version of the Pay
Now button or a Pay Now button for all payment methods.
@property (nonatomic, retain) NSString *displayPayNowButton
Discussion
If set, this field determines whether a Pay Now button is displayed for all of the
user’s listings. The user has the option of using a PayPal only version of the Pay
Now button or a Pay Now button for all payment methods.
type: string constant in Trading_DisplayPayNowButtonCodeType.h
Declared In
Trading_SellerPaymentPreferencesType.h
fedExRateOption
Specifies the type of FedEx rates to use.
@property (nonatomic, retain) NSString *fedExRateOption
Discussion
Specifies the type of FedEx rates to use.
type: string constant in Trading_FedExRateOptionCodeType.h
Declared In
Trading_SellerPaymentPreferencesType.h
payPalAlwaysOn
Indicates whether PayPal is always accepted for the seller’s listings.
@property (nonatomic, retain) NSNumber *payPalAlwaysOn
Discussion
Indicates whether PayPal is always accepted for the seller’s listings.
type : NSNumber, wrapper for primitive bool
Declared In
Trading_SellerPaymentPreferencesType.h
payPalPreferred
Specifies whether a seller wants to let buyers know that PayPal payments
are preferred.
@property (nonatomic, retain) NSNumber *payPalPreferred
Discussion
Specifies whether a seller wants to let buyers know that PayPal payments
are preferred.
type : NSNumber, wrapper for primitive bool
Declared In
Trading_SellerPaymentPreferencesType.h
sellerPaymentAddress
Specifies the address the seller uses to receive mailed payments from buyers.
@property (nonatomic, retain) Trading_AddressType *sellerPaymentAddress
Discussion
Specifies the address the seller uses to receive mailed payments from buyers.
type : class Trading_AddressType
Declared In
Trading_SellerPaymentPreferencesType.h
upsRateOption
Specifies the type of United Parcel Service rates to use.
@property (nonatomic, retain) NSString *upsRateOption
Discussion
Specifies the type of United Parcel Service rates to use.
type: string constant in Trading_UPSRateOptionCodeType.h
Declared In
Trading_SellerPaymentPreferencesType.h