Skip to content
Projects
Groups
Snippets
Help
Loading...
Help
Support
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
L
linux-davinci
Project overview
Project overview
Details
Activity
Releases
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Issues
0
Issues
0
List
Boards
Labels
Milestones
Redmine
Redmine
Merge Requests
0
Merge Requests
0
CI / CD
CI / CD
Pipelines
Jobs
Schedules
Operations
Operations
Metrics
Environments
Analytics
Analytics
CI / CD
Repository
Value Stream
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Create a new issue
Jobs
Commits
Issue Boards
Open sidebar
linux
linux-davinci
Commits
923fd00e
Commit
923fd00e
authored
Sep 15, 2009
by
Stephen Rothwell
Browse files
Options
Browse Files
Download
Plain Diff
Merge commit 'infiniband/for-next'
parents
a56250b9
16e36679
Changes
9
Expand all
Show whitespace changes
Inline
Side-by-side
Showing
9 changed files
with
1060 additions
and
1 deletion
+1060
-1
Documentation/Makefile
Documentation/Makefile
+2
-1
Documentation/ummunotify/Makefile
Documentation/ummunotify/Makefile
+7
-0
Documentation/ummunotify/ummunotify.txt
Documentation/ummunotify/ummunotify.txt
+150
-0
Documentation/ummunotify/umn-test.c
Documentation/ummunotify/umn-test.c
+200
-0
drivers/char/Kconfig
drivers/char/Kconfig
+12
-0
drivers/char/Makefile
drivers/char/Makefile
+1
-0
drivers/char/ummunotify.c
drivers/char/ummunotify.c
+566
-0
include/linux/Kbuild
include/linux/Kbuild
+1
-0
include/linux/ummunotify.h
include/linux/ummunotify.h
+121
-0
No files found.
Documentation/Makefile
View file @
923fd00e
obj-m
:=
DocBook/ accounting/ auxdisplay/ connector/
\
filesystems/configfs/ ia64/ networking/
\
pcmcia/ spi/ video4linux/ vm/ watchdog/src/
pcmcia/ spi/ video4linux/ vm/ ummunotify/
\
watchdog/src/
Documentation/ummunotify/Makefile
0 → 100644
View file @
923fd00e
# List of programs to build
hostprogs-y
:=
umn-test
# Tell kbuild to always build the programs
always
:=
$
(
hostprogs-y
)
HOSTCFLAGS_umn-test.o
+=
-I
$(objtree)
/usr/include
Documentation/ummunotify/ummunotify.txt
0 → 100644
View file @
923fd00e
UMMUNOTIFY
Ummunotify relays MMU notifier events to userspace. This is useful
for libraries that need to track the memory mapping of applications;
for example, MPI implementations using RDMA want to cache memory
registrations for performance, but tracking all possible crazy cases
such as when, say, the FORTRAN runtime frees memory is impossible
without kernel help.
Basic Model
A userspace process uses it by opening /dev/ummunotify, which
returns a file descriptor. Interest in address ranges is registered
using ioctl() and MMU notifier events are retrieved using read(), as
described in more detail below. Userspace can register multiple
address ranges to watch, and can unregister individual ranges.
Userspace can also mmap() a single read-only page at offset 0 on
this file descriptor. This page contains (at offest 0) a single
64-bit generation counter that the kernel increments each time an
MMU notifier event occurs. Userspace can use this to very quickly
check if there are any events to retrieve without needing to do a
system call.
Control
To start using ummunotify, a process opens /dev/ummunotify in
read-only mode. Control from userspace is done via ioctl(); the
defined ioctls are:
UMMUNOTIFY_EXCHANGE_FEATURES: This ioctl takes a single 32-bit
word of feature flags as input, and the kernel updates the
features flags word to contain only features requested by
userspace and also supported by the kernel.
This ioctl is only included for forward compatibility; no
feature flags are currently defined, and the kernel will simply
update any requested feature mask to 0. The kernel will always
default to a feature mask of 0 if this ioctl is not used, so
current userspace does not need to perform this ioctl.
UMMUNOTIFY_REGISTER_REGION: Userspace uses this ioctl to tell the
kernel to start delivering events for an address range. The
range is described using struct ummunotify_register_ioctl:
struct ummunotify_register_ioctl {
__u64 start;
__u64 end;
__u64 user_cookie;
__u32 flags;
__u32 reserved;
};
start and end give the range of userspace virtual addresses;
start is included in the range and end is not, so an example of
a 4 KB range would be start=0x1000, end=0x2000.
user_cookie is an opaque 64-bit quantity that is returned by the
kernel in events involving the range, and used by userspace to
stop watching the range. Each registered address range must
have a distinct user_cookie.
It is fine with the kernel if userspace registers multiple
overlapping or even duplicate address ranges, as long as a
different cookie is used for each registration.
flags and reserved are included for forward compatibility;
userspace should simply set them to 0 for the current interface.
UMMUNOTIFY_UNREGISTER_REGION: Userspace passes in the 64-bit
user_cookie used to register a range to tell the kernel to stop
watching an address range. Once this ioctl completes, the
kernel will not deliver any further events for the range that is
unregistered.
Events
When an event occurs that invalidates some of a process's memory
mapping in an address range being watched, ummunotify queues an
event report for that address range. If more than one event
invalidates parts of the same address range before userspace
retrieves the queued report, then further reports for the same range
will not be queued -- when userspace does read the queue, only a
single report for a given range will be returned.
If multiple ranges being watched are invalidated by a single event
(which is especially likely if userspace registers overlapping
ranges), then an event report structure will be queued for each
address range registration.
Userspace retrieves queued events via read() on the ummunotify file
descriptor; a buffer that is at least as big as struct
ummunotify_event should be used to retrieve event reports, and if a
larger buffer is passed to read(), multiple reports will be returned
(if available).
If the ummunotify file descriptor is in blocking mode, a read() call
will wait for an event report to be available. Userspace may also
set the ummunotify file descriptor to non-blocking mode and use all
standard ways of waiting for data to be available on the ummunotify
file descriptor, including epoll/poll()/select() and SIGIO.
The format of event reports is:
struct ummunotify_event {
__u32 type;
__u32 flags;
__u64 hint_start;
__u64 hint_end;
__u64 user_cookie_counter;
};
where the type field is either UMMUNOTIFY_EVENT_TYPE_INVAL or
UMMUNOTIFY_EVENT_TYPE_LAST. Events of type INVAL describe
invalidation events as follows: user_cookie_counter contains the
cookie passed in when userspace registered the range that the event
is for. hint_start and hint_end contain the start address and end
address that were invalidated.
The flags word contains bit flags, with only UMMUNOTIFY_EVENT_FLAG_HINT
defined at the moment. If HINT is set, then the invalidation event
invalidated less than the full address range and the kernel returns
the exact range invalidated; if HINT is not sent then hint_start and
hint_end are set to the original range registered by userspace.
(HINT will not be set if, for example, multiple events invalidated
disjoint parts of the range and so a single start/end pair cannot
represent the parts of the range that were invalidated)
If the event type is LAST, then the read operation has emptied the
list of invalidated regions, and the flags, hint_start and hint_end
fields are not used. user_cookie_counter holds the value of the
kernel's generation counter (see below of more details) when the
empty list occurred.
Generation Count
Userspace may mmap() a page on a ummunotify file descriptor via
mmap(NULL, sizeof (__u64), PROT_READ, MAP_SHARED, ummunotify_fd, 0);
to get a read-only mapping of the kernel's 64-bit generation
counter. The kernel will increment this generation counter each
time an event report is queued.
Userspace can use the generation counter as a quick check to avoid
system calls; if the value read from the mapped kernel counter is
still equal to the value returned in user_cookie_counter for the
most recent LAST event retrieved, then no further events have been
queued and there is no need to try a read() on the ummunotify file
descriptor.
Documentation/ummunotify/umn-test.c
0 → 100644
View file @
923fd00e
/*
* Copyright (c) 2009 Cisco Systems. All rights reserved.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License version
* 2 as published by the Free Software Foundation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <stdint.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <linux/ummunotify.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#define UMN_TEST_COOKIE 123
static
int
umn_fd
;
static
volatile
__u64
*
umn_counter
;
static
int
umn_init
(
void
)
{
__u32
flags
;
umn_fd
=
open
(
"/dev/ummunotify"
,
O_RDONLY
);
if
(
umn_fd
<
0
)
{
perror
(
"open"
);
return
1
;
}
if
(
ioctl
(
umn_fd
,
UMMUNOTIFY_EXCHANGE_FEATURES
,
&
flags
))
{
perror
(
"exchange ioctl"
);
return
1
;
}
printf
(
"kernel feature flags: 0x%08x
\n
"
,
flags
);
umn_counter
=
mmap
(
NULL
,
sizeof
*
umn_counter
,
PROT_READ
,
MAP_SHARED
,
umn_fd
,
0
);
if
(
umn_counter
==
MAP_FAILED
)
{
perror
(
"mmap"
);
return
1
;
}
return
0
;
}
static
int
umn_register
(
void
*
buf
,
size_t
size
,
__u64
cookie
)
{
struct
ummunotify_register_ioctl
r
=
{
.
start
=
(
unsigned
long
)
buf
,
.
end
=
(
unsigned
long
)
buf
+
size
,
.
user_cookie
=
cookie
,
};
if
(
ioctl
(
umn_fd
,
UMMUNOTIFY_REGISTER_REGION
,
&
r
))
{
perror
(
"register ioctl"
);
return
1
;
}
return
0
;
}
static
int
umn_unregister
(
__u64
cookie
)
{
if
(
ioctl
(
umn_fd
,
UMMUNOTIFY_UNREGISTER_REGION
,
&
cookie
))
{
perror
(
"unregister ioctl"
);
return
1
;
}
return
0
;
}
int
main
(
int
argc
,
char
*
argv
[])
{
int
page_size
;
__u64
old_counter
;
void
*
t
;
int
got_it
;
if
(
umn_init
())
return
1
;
printf
(
"
\n
"
);
old_counter
=
*
umn_counter
;
if
(
old_counter
!=
0
)
{
fprintf
(
stderr
,
"counter = %lld (expected 0)
\n
"
,
old_counter
);
return
1
;
}
page_size
=
sysconf
(
_SC_PAGESIZE
);
t
=
mmap
(
NULL
,
3
*
page_size
,
PROT_READ
,
MAP_PRIVATE
|
MAP_ANONYMOUS
|
MAP_POPULATE
,
-
1
,
0
);
if
(
umn_register
(
t
,
3
*
page_size
,
UMN_TEST_COOKIE
))
return
1
;
munmap
(
t
+
page_size
,
page_size
);
old_counter
=
*
umn_counter
;
if
(
old_counter
!=
1
)
{
fprintf
(
stderr
,
"counter = %lld (expected 1)
\n
"
,
old_counter
);
return
1
;
}
got_it
=
0
;
while
(
1
)
{
struct
ummunotify_event
ev
;
int
len
;
len
=
read
(
umn_fd
,
&
ev
,
sizeof
ev
);
if
(
len
<
0
)
{
perror
(
"read event"
);
return
1
;
}
if
(
len
!=
sizeof
ev
)
{
fprintf
(
stderr
,
"Read gave %d bytes (!= event size %zd)
\n
"
,
len
,
sizeof
ev
);
return
1
;
}
switch
(
ev
.
type
)
{
case
UMMUNOTIFY_EVENT_TYPE_INVAL
:
if
(
got_it
)
{
fprintf
(
stderr
,
"Extra invalidate event
\n
"
);
return
1
;
}
if
(
ev
.
user_cookie_counter
!=
UMN_TEST_COOKIE
)
{
fprintf
(
stderr
,
"Invalidate event for cookie %lld (expected %d)
\n
"
,
ev
.
user_cookie_counter
,
UMN_TEST_COOKIE
);
return
1
;
}
printf
(
"Invalidate event:
\t
cookie %lld
\n
"
,
ev
.
user_cookie_counter
);
if
(
!
(
ev
.
flags
&
UMMUNOTIFY_EVENT_FLAG_HINT
))
{
fprintf
(
stderr
,
"Hint flag not set
\n
"
);
return
1
;
}
if
(
ev
.
hint_start
!=
(
uintptr_t
)
t
+
page_size
||
ev
.
hint_end
!=
(
uintptr_t
)
t
+
page_size
*
2
)
{
fprintf
(
stderr
,
"Got hint %llx..%llx, expected %p..%p
\n
"
,
ev
.
hint_start
,
ev
.
hint_end
,
t
+
page_size
,
t
+
page_size
*
2
);
return
1
;
}
printf
(
"
\t\t\t
hint %llx...%llx
\n
"
,
ev
.
hint_start
,
ev
.
hint_end
);
got_it
=
1
;
break
;
case
UMMUNOTIFY_EVENT_TYPE_LAST
:
if
(
!
got_it
)
{
fprintf
(
stderr
,
"Last event without invalidate event
\n
"
);
return
1
;
}
printf
(
"Empty event:
\t\t
counter %lld
\n
"
,
ev
.
user_cookie_counter
);
goto
done
;
default:
fprintf
(
stderr
,
"unknown event type %d
\n
"
,
ev
.
type
);
return
1
;
}
}
done:
umn_unregister
(
123
);
munmap
(
t
,
page_size
);
old_counter
=
*
umn_counter
;
if
(
old_counter
!=
1
)
{
fprintf
(
stderr
,
"counter = %lld (expected 1)
\n
"
,
old_counter
);
return
1
;
}
return
0
;
}
drivers/char/Kconfig
View file @
923fd00e
...
...
@@ -1108,6 +1108,18 @@ config DEVPORT
depends on ISA || PCI
default y
config UMMUNOTIFY
tristate "Userspace MMU notifications"
select MMU_NOTIFIER
help
The ummunotify (userspace MMU notification) driver creates a
character device that can be used by userspace libraries to
get notifications when an application's memory mapping
changed. This is used, for example, by RDMA libraries to
improve the reliability of memory registration caching, since
the kernel's MMU notifications can be used to know precisely
when to shoot down a cached registration.
source "drivers/s390/char/Kconfig"
endmenu
...
...
drivers/char/Makefile
View file @
923fd00e
...
...
@@ -97,6 +97,7 @@ obj-$(CONFIG_NSC_GPIO) += nsc_gpio.o
obj-$(CONFIG_CS5535_GPIO)
+=
cs5535_gpio.o
obj-$(CONFIG_GPIO_TB0219)
+=
tb0219.o
obj-$(CONFIG_TELCLOCK)
+=
tlclk.o
obj-$(CONFIG_UMMUNOTIFY)
+=
ummunotify.o
obj-$(CONFIG_MWAVE)
+=
mwave/
obj-$(CONFIG_AGP)
+=
agp/
...
...
drivers/char/ummunotify.c
0 → 100644
View file @
923fd00e
This diff is collapsed.
Click to expand it.
include/linux/Kbuild
View file @
923fd00e
...
...
@@ -159,6 +159,7 @@ header-y += tipc_config.h
header-y += toshiba.h
header-y += udf_fs_i.h
header-y += ultrasound.h
header-y += ummunotify.h
header-y += un.h
header-y += utime.h
header-y += veth.h
...
...
include/linux/ummunotify.h
0 → 100644
View file @
923fd00e
/*
* Copyright (c) 2009 Cisco Systems. All rights reserved.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License version
* 2 as published by the Free Software Foundation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#ifndef _LINUX_UMMUNOTIFY_H
#define _LINUX_UMMUNOTIFY_H
#include <linux/types.h>
#include <linux/ioctl.h>
/*
* Ummunotify relays MMU notifier events to userspace. A userspace
* process uses it by opening /dev/ummunotify, which returns a file
* descriptor. Interest in address ranges is registered using ioctl()
* and MMU notifier events are retrieved using read(), as described in
* more detail below.
*
* Userspace can also mmap() a single read-only page at offset 0 on
* this file descriptor. This page contains (at offest 0) a single
* 64-bit generation counter that the kernel increments each time an
* MMU notifier event occurs. Userspace can use this to very quickly
* check if there are any events to retrieve without needing to do a
* system call.
*/
/*
* struct ummunotify_register_ioctl describes an address range from
* start to end (including start but not including end) to be
* monitored. user_cookie is an opaque handle that userspace assigns,
* and which is used to unregister. flags and reserved are currently
* unused and should be set to 0 for forward compatibility.
*/
struct
ummunotify_register_ioctl
{
__u64
start
;
__u64
end
;
__u64
user_cookie
;
__u32
flags
;
__u32
reserved
;
};
#define UMMUNOTIFY_MAGIC 'U'
/*
* Forward compatibility: Userspace passes in a 32-bit feature mask
* with feature flags set indicating which extensions it wishes to
* use. The kernel will return a feature mask with the bits of
* userspace's mask that the kernel implements; from that point on
* both userspace and the kernel should behave as described by the
* kernel's feature mask.
*
* If userspace does not perform a UMMUNOTIFY_EXCHANGE_FEATURES ioctl,
* then the kernel will use a feature mask of 0.
*
* No feature flags are currently defined, so the kernel will always
* return a feature mask of 0 at present.
*/
#define UMMUNOTIFY_EXCHANGE_FEATURES _IOWR(UMMUNOTIFY_MAGIC, 1, __u32)
/*
* Register interest in an address range; userspace should pass in a
* struct ummunotify_register_ioctl describing the region.
*/
#define UMMUNOTIFY_REGISTER_REGION _IOW(UMMUNOTIFY_MAGIC, 2, \
struct ummunotify_register_ioctl)
/*
* Unregister interest in an address range; userspace should pass in
* the user_cookie value that was used to register the address range.
* No events for the address range will be reported once it is
* unregistered.
*/
#define UMMUNOTIFY_UNREGISTER_REGION _IOW(UMMUNOTIFY_MAGIC, 3, __u64)
/*
* Invalidation events are returned whenever the kernel changes the
* mapping for a monitored address. These events are retrieved by
* read() on the ummunotify file descriptor, which will fill the
* read() buffer with struct ummunotify_event.
*
* If type field is INVAL, then user_cookie_counter holds the
* user_cookie for the region being reported; if the HINT flag is set
* then hint_start/hint_end hold the start and end of the mapping that
* was invalidated. (If HINT is not set, then multiple events
* invalidated parts of the registered range and hint_start/hint_end
* and set to the start/end of the whole registered range)
*
* If type is LAST, then the read operation has emptied the list of
* invalidated regions, and user_cookie_counter holds the value of the
* kernel's generation counter when the empty list occurred. The
* other fields are not filled in for this event.
*/
enum
{
UMMUNOTIFY_EVENT_TYPE_INVAL
=
0
,
UMMUNOTIFY_EVENT_TYPE_LAST
=
1
,
};
enum
{
UMMUNOTIFY_EVENT_FLAG_HINT
=
1
<<
0
,
};
struct
ummunotify_event
{
__u32
type
;
__u32
flags
;
__u64
hint_start
;
__u64
hint_end
;
__u64
user_cookie_counter
;
};
#endif
/* _LINUX_UMMUNOTIFY_H */
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment