2008-02-08 05:18:22 -07:00
|
|
|
#ifndef __IPC_NAMESPACE_H__
|
|
|
|
#define __IPC_NAMESPACE_H__
|
|
|
|
|
|
|
|
#include <linux/err.h>
|
2008-02-08 05:18:57 -07:00
|
|
|
#include <linux/idr.h>
|
|
|
|
#include <linux/rwsem.h>
|
2008-04-29 02:00:42 -06:00
|
|
|
#include <linux/notifier.h>
|
2011-03-23 17:43:24 -06:00
|
|
|
#include <linux/nsproxy.h>
|
2008-04-29 02:00:42 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* ipc namespace events
|
|
|
|
*/
|
|
|
|
#define IPCNS_MEMCHANGED 0x00000001 /* Notify lowmem size changed */
|
2008-04-29 02:00:44 -06:00
|
|
|
#define IPCNS_CREATED 0x00000002 /* Notify new ipc namespace created */
|
|
|
|
#define IPCNS_REMOVED 0x00000003 /* Notify ipc namespace removed */
|
2008-04-29 02:00:42 -06:00
|
|
|
|
|
|
|
#define IPCNS_CALLBACK_PRI 0
|
|
|
|
|
2011-03-23 17:43:23 -06:00
|
|
|
struct user_namespace;
|
2008-02-08 05:18:57 -07:00
|
|
|
|
|
|
|
struct ipc_ids {
|
|
|
|
int in_use;
|
|
|
|
unsigned short seq;
|
|
|
|
unsigned short seq_max;
|
|
|
|
struct rw_semaphore rw_mutex;
|
|
|
|
struct idr ipcs_idr;
|
|
|
|
};
|
2008-02-08 05:18:22 -07:00
|
|
|
|
|
|
|
struct ipc_namespace {
|
namespaces: ipc namespaces: implement support for posix msqueues
Implement multiple mounts of the mqueue file system, and link it to usage
of CLONE_NEWIPC.
Each ipc ns has a corresponding mqueuefs superblock. When a user does
clone(CLONE_NEWIPC) or unshare(CLONE_NEWIPC), the unshare will cause an
internal mount of a new mqueuefs sb linked to the new ipc ns.
When a user does 'mount -t mqueue mqueue /dev/mqueue', he mounts the
mqueuefs superblock.
Posix message queues can be worked with both through the mq_* system calls
(see mq_overview(7)), and through the VFS through the mqueue mount. Any
usage of mq_open() and friends will work with the acting task's ipc
namespace. Any actions through the VFS will work with the mqueuefs in
which the file was created. So if a user doesn't remount mqueuefs after
unshare(CLONE_NEWIPC), mq_open("/ab") will not be reflected in "ls
/dev/mqueue".
If task a mounts mqueue for ipc_ns:1, then clones task b with a new ipcns,
ipcns:2, and then task a is the last task in ipc_ns:1 to exit, then (1)
ipc_ns:1 will be freed, (2) it's superblock will live on until task b
umounts the corresponding mqueuefs, and vfs actions will continue to
succeed, but (3) sb->s_fs_info will be NULL for the sb corresponding to
the deceased ipc_ns:1.
To make this happen, we must protect the ipc reference count when
a) a task exits and drops its ipcns->count, since it might be dropping
it to 0 and freeing the ipcns
b) a task accesses the ipcns through its mqueuefs interface, since it
bumps the ipcns refcount and might race with the last task in the ipcns
exiting.
So the kref is changed to an atomic_t so we can use
atomic_dec_and_lock(&ns->count,mq_lock), and every access to the ipcns
through ns = mqueuefs_sb->s_fs_info is protected by the same lock.
Signed-off-by: Cedric Le Goater <clg@fr.ibm.com>
Signed-off-by: Serge E. Hallyn <serue@us.ibm.com>
Cc: Alexey Dobriyan <adobriyan@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-06 20:01:10 -06:00
|
|
|
atomic_t count;
|
2008-02-08 05:18:57 -07:00
|
|
|
struct ipc_ids ids[3];
|
2008-02-08 05:18:22 -07:00
|
|
|
|
|
|
|
int sem_ctls[4];
|
|
|
|
int used_sems;
|
|
|
|
|
|
|
|
int msg_ctlmax;
|
|
|
|
int msg_ctlmnb;
|
|
|
|
int msg_ctlmni;
|
|
|
|
atomic_t msg_bytes;
|
|
|
|
atomic_t msg_hdrs;
|
2008-07-25 02:48:08 -06:00
|
|
|
int auto_msgmni;
|
2008-02-08 05:18:22 -07:00
|
|
|
|
|
|
|
size_t shm_ctlmax;
|
|
|
|
size_t shm_ctlall;
|
|
|
|
int shm_ctlmni;
|
|
|
|
int shm_tot;
|
2011-07-26 17:08:48 -06:00
|
|
|
/*
|
|
|
|
* Defines whether IPC_RMID is forced for _all_ shm segments regardless
|
|
|
|
* of shmctl()
|
|
|
|
*/
|
|
|
|
int shm_rmid_forced;
|
2008-04-29 02:00:42 -06:00
|
|
|
|
|
|
|
struct notifier_block ipcns_nb;
|
2009-04-06 20:01:08 -06:00
|
|
|
|
|
|
|
/* The kern_mount of the mqueuefs sb. We take a ref on it */
|
|
|
|
struct vfsmount *mq_mnt;
|
|
|
|
|
|
|
|
/* # queues in this ns, protected by mq_lock */
|
|
|
|
unsigned int mq_queues_count;
|
|
|
|
|
|
|
|
/* next fields are set through sysctl */
|
|
|
|
unsigned int mq_queues_max; /* initialized to DFLT_QUEUESMAX */
|
|
|
|
unsigned int mq_msg_max; /* initialized to DFLT_MSGMAX */
|
|
|
|
unsigned int mq_msgsize_max; /* initialized to DFLT_MSGSIZEMAX */
|
2012-05-31 17:26:33 -06:00
|
|
|
unsigned int mq_msg_default;
|
|
|
|
unsigned int mq_msgsize_default;
|
2009-04-06 20:01:08 -06:00
|
|
|
|
2011-03-23 17:43:23 -06:00
|
|
|
/* user_ns which owns the ipc ns */
|
|
|
|
struct user_namespace *user_ns;
|
2008-02-08 05:18:22 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
extern struct ipc_namespace init_ipc_ns;
|
2008-04-29 02:00:40 -06:00
|
|
|
extern atomic_t nr_ipc_ns;
|
2008-02-08 05:18:22 -07:00
|
|
|
|
namespaces: ipc namespaces: implement support for posix msqueues
Implement multiple mounts of the mqueue file system, and link it to usage
of CLONE_NEWIPC.
Each ipc ns has a corresponding mqueuefs superblock. When a user does
clone(CLONE_NEWIPC) or unshare(CLONE_NEWIPC), the unshare will cause an
internal mount of a new mqueuefs sb linked to the new ipc ns.
When a user does 'mount -t mqueue mqueue /dev/mqueue', he mounts the
mqueuefs superblock.
Posix message queues can be worked with both through the mq_* system calls
(see mq_overview(7)), and through the VFS through the mqueue mount. Any
usage of mq_open() and friends will work with the acting task's ipc
namespace. Any actions through the VFS will work with the mqueuefs in
which the file was created. So if a user doesn't remount mqueuefs after
unshare(CLONE_NEWIPC), mq_open("/ab") will not be reflected in "ls
/dev/mqueue".
If task a mounts mqueue for ipc_ns:1, then clones task b with a new ipcns,
ipcns:2, and then task a is the last task in ipc_ns:1 to exit, then (1)
ipc_ns:1 will be freed, (2) it's superblock will live on until task b
umounts the corresponding mqueuefs, and vfs actions will continue to
succeed, but (3) sb->s_fs_info will be NULL for the sb corresponding to
the deceased ipc_ns:1.
To make this happen, we must protect the ipc reference count when
a) a task exits and drops its ipcns->count, since it might be dropping
it to 0 and freeing the ipcns
b) a task accesses the ipcns through its mqueuefs interface, since it
bumps the ipcns refcount and might race with the last task in the ipcns
exiting.
So the kref is changed to an atomic_t so we can use
atomic_dec_and_lock(&ns->count,mq_lock), and every access to the ipcns
through ns = mqueuefs_sb->s_fs_info is protected by the same lock.
Signed-off-by: Cedric Le Goater <clg@fr.ibm.com>
Signed-off-by: Serge E. Hallyn <serue@us.ibm.com>
Cc: Alexey Dobriyan <adobriyan@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-06 20:01:10 -06:00
|
|
|
extern spinlock_t mq_lock;
|
2008-04-29 02:00:42 -06:00
|
|
|
|
2009-04-06 20:01:08 -06:00
|
|
|
#ifdef CONFIG_SYSVIPC
|
2008-04-29 02:00:42 -06:00
|
|
|
extern int register_ipcns_notifier(struct ipc_namespace *);
|
2008-04-29 02:00:45 -06:00
|
|
|
extern int cond_register_ipcns_notifier(struct ipc_namespace *);
|
2008-07-25 02:48:08 -06:00
|
|
|
extern void unregister_ipcns_notifier(struct ipc_namespace *);
|
2008-04-29 02:00:42 -06:00
|
|
|
extern int ipcns_notify(unsigned long);
|
2011-07-26 17:08:48 -06:00
|
|
|
extern void shm_destroy_orphaned(struct ipc_namespace *ns);
|
2008-04-29 02:00:42 -06:00
|
|
|
#else /* CONFIG_SYSVIPC */
|
2009-04-06 20:01:08 -06:00
|
|
|
static inline int register_ipcns_notifier(struct ipc_namespace *ns)
|
|
|
|
{ return 0; }
|
|
|
|
static inline int cond_register_ipcns_notifier(struct ipc_namespace *ns)
|
|
|
|
{ return 0; }
|
|
|
|
static inline void unregister_ipcns_notifier(struct ipc_namespace *ns) { }
|
|
|
|
static inline int ipcns_notify(unsigned long l) { return 0; }
|
2011-07-26 17:08:48 -06:00
|
|
|
static inline void shm_destroy_orphaned(struct ipc_namespace *ns) {}
|
2008-04-29 02:00:42 -06:00
|
|
|
#endif /* CONFIG_SYSVIPC */
|
2008-02-08 05:18:22 -07:00
|
|
|
|
2009-04-06 20:01:08 -06:00
|
|
|
#ifdef CONFIG_POSIX_MQUEUE
|
namespaces: ipc namespaces: implement support for posix msqueues
Implement multiple mounts of the mqueue file system, and link it to usage
of CLONE_NEWIPC.
Each ipc ns has a corresponding mqueuefs superblock. When a user does
clone(CLONE_NEWIPC) or unshare(CLONE_NEWIPC), the unshare will cause an
internal mount of a new mqueuefs sb linked to the new ipc ns.
When a user does 'mount -t mqueue mqueue /dev/mqueue', he mounts the
mqueuefs superblock.
Posix message queues can be worked with both through the mq_* system calls
(see mq_overview(7)), and through the VFS through the mqueue mount. Any
usage of mq_open() and friends will work with the acting task's ipc
namespace. Any actions through the VFS will work with the mqueuefs in
which the file was created. So if a user doesn't remount mqueuefs after
unshare(CLONE_NEWIPC), mq_open("/ab") will not be reflected in "ls
/dev/mqueue".
If task a mounts mqueue for ipc_ns:1, then clones task b with a new ipcns,
ipcns:2, and then task a is the last task in ipc_ns:1 to exit, then (1)
ipc_ns:1 will be freed, (2) it's superblock will live on until task b
umounts the corresponding mqueuefs, and vfs actions will continue to
succeed, but (3) sb->s_fs_info will be NULL for the sb corresponding to
the deceased ipc_ns:1.
To make this happen, we must protect the ipc reference count when
a) a task exits and drops its ipcns->count, since it might be dropping
it to 0 and freeing the ipcns
b) a task accesses the ipcns through its mqueuefs interface, since it
bumps the ipcns refcount and might race with the last task in the ipcns
exiting.
So the kref is changed to an atomic_t so we can use
atomic_dec_and_lock(&ns->count,mq_lock), and every access to the ipcns
through ns = mqueuefs_sb->s_fs_info is protected by the same lock.
Signed-off-by: Cedric Le Goater <clg@fr.ibm.com>
Signed-off-by: Serge E. Hallyn <serue@us.ibm.com>
Cc: Alexey Dobriyan <adobriyan@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-06 20:01:10 -06:00
|
|
|
extern int mq_init_ns(struct ipc_namespace *ns);
|
2012-05-31 17:26:30 -06:00
|
|
|
/*
|
|
|
|
* POSIX Message Queue default values:
|
|
|
|
*
|
|
|
|
* MIN_*: Lowest value an admin can set the maximum unprivileged limit to
|
|
|
|
* DFLT_*MAX: Default values for the maximum unprivileged limits
|
|
|
|
* DFLT_{MSG,MSGSIZE}: Default values used when the user doesn't supply
|
|
|
|
* an attribute to the open call and the queue must be created
|
|
|
|
* HARD_*: Highest value the maximums can be set to. These are enforced
|
|
|
|
* on CAP_SYS_RESOURCE apps as well making them inviolate (so make them
|
|
|
|
* suitably high)
|
|
|
|
*
|
|
|
|
* POSIX Requirements:
|
|
|
|
* Per app minimum openable message queues - 8. This does not map well
|
|
|
|
* to the fact that we limit the number of queues on a per namespace
|
|
|
|
* basis instead of a per app basis. So, make the default high enough
|
|
|
|
* that no given app should have a hard time opening 8 queues.
|
|
|
|
* Minimum maximum for HARD_MSGMAX - 32767. I bumped this to 65536.
|
|
|
|
* Minimum maximum for HARD_MSGSIZEMAX - POSIX is silent on this. However,
|
|
|
|
* we have run into a situation where running applications in the wild
|
|
|
|
* require this to be at least 5MB, and preferably 10MB, so I set the
|
|
|
|
* value to 16MB in hopes that this user is the worst of the bunch and
|
|
|
|
* the new maximum will handle anyone else. I may have to revisit this
|
|
|
|
* in the future.
|
|
|
|
*/
|
|
|
|
#define MIN_QUEUESMAX 1
|
|
|
|
#define DFLT_QUEUESMAX 256
|
|
|
|
#define HARD_QUEUESMAX 1024
|
|
|
|
#define MIN_MSGMAX 1
|
2012-05-31 17:26:31 -06:00
|
|
|
#define DFLT_MSG 10U
|
|
|
|
#define DFLT_MSGMAX 10
|
2012-05-31 17:26:30 -06:00
|
|
|
#define HARD_MSGMAX 65536
|
|
|
|
#define MIN_MSGSIZEMAX 128
|
|
|
|
#define DFLT_MSGSIZE 8192U
|
2012-05-31 17:26:31 -06:00
|
|
|
#define DFLT_MSGSIZEMAX 8192
|
2012-05-31 17:26:30 -06:00
|
|
|
#define HARD_MSGSIZEMAX (16*1024*1024)
|
2009-04-06 20:01:08 -06:00
|
|
|
#else
|
namespaces: ipc namespaces: implement support for posix msqueues
Implement multiple mounts of the mqueue file system, and link it to usage
of CLONE_NEWIPC.
Each ipc ns has a corresponding mqueuefs superblock. When a user does
clone(CLONE_NEWIPC) or unshare(CLONE_NEWIPC), the unshare will cause an
internal mount of a new mqueuefs sb linked to the new ipc ns.
When a user does 'mount -t mqueue mqueue /dev/mqueue', he mounts the
mqueuefs superblock.
Posix message queues can be worked with both through the mq_* system calls
(see mq_overview(7)), and through the VFS through the mqueue mount. Any
usage of mq_open() and friends will work with the acting task's ipc
namespace. Any actions through the VFS will work with the mqueuefs in
which the file was created. So if a user doesn't remount mqueuefs after
unshare(CLONE_NEWIPC), mq_open("/ab") will not be reflected in "ls
/dev/mqueue".
If task a mounts mqueue for ipc_ns:1, then clones task b with a new ipcns,
ipcns:2, and then task a is the last task in ipc_ns:1 to exit, then (1)
ipc_ns:1 will be freed, (2) it's superblock will live on until task b
umounts the corresponding mqueuefs, and vfs actions will continue to
succeed, but (3) sb->s_fs_info will be NULL for the sb corresponding to
the deceased ipc_ns:1.
To make this happen, we must protect the ipc reference count when
a) a task exits and drops its ipcns->count, since it might be dropping
it to 0 and freeing the ipcns
b) a task accesses the ipcns through its mqueuefs interface, since it
bumps the ipcns refcount and might race with the last task in the ipcns
exiting.
So the kref is changed to an atomic_t so we can use
atomic_dec_and_lock(&ns->count,mq_lock), and every access to the ipcns
through ns = mqueuefs_sb->s_fs_info is protected by the same lock.
Signed-off-by: Cedric Le Goater <clg@fr.ibm.com>
Signed-off-by: Serge E. Hallyn <serue@us.ibm.com>
Cc: Alexey Dobriyan <adobriyan@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-06 20:01:10 -06:00
|
|
|
static inline int mq_init_ns(struct ipc_namespace *ns) { return 0; }
|
2009-04-06 20:01:08 -06:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(CONFIG_IPC_NS)
|
2008-02-08 05:18:22 -07:00
|
|
|
extern struct ipc_namespace *copy_ipcs(unsigned long flags,
|
2011-03-23 17:43:24 -06:00
|
|
|
struct task_struct *tsk);
|
2008-02-08 05:18:22 -07:00
|
|
|
static inline struct ipc_namespace *get_ipc_ns(struct ipc_namespace *ns)
|
|
|
|
{
|
|
|
|
if (ns)
|
namespaces: ipc namespaces: implement support for posix msqueues
Implement multiple mounts of the mqueue file system, and link it to usage
of CLONE_NEWIPC.
Each ipc ns has a corresponding mqueuefs superblock. When a user does
clone(CLONE_NEWIPC) or unshare(CLONE_NEWIPC), the unshare will cause an
internal mount of a new mqueuefs sb linked to the new ipc ns.
When a user does 'mount -t mqueue mqueue /dev/mqueue', he mounts the
mqueuefs superblock.
Posix message queues can be worked with both through the mq_* system calls
(see mq_overview(7)), and through the VFS through the mqueue mount. Any
usage of mq_open() and friends will work with the acting task's ipc
namespace. Any actions through the VFS will work with the mqueuefs in
which the file was created. So if a user doesn't remount mqueuefs after
unshare(CLONE_NEWIPC), mq_open("/ab") will not be reflected in "ls
/dev/mqueue".
If task a mounts mqueue for ipc_ns:1, then clones task b with a new ipcns,
ipcns:2, and then task a is the last task in ipc_ns:1 to exit, then (1)
ipc_ns:1 will be freed, (2) it's superblock will live on until task b
umounts the corresponding mqueuefs, and vfs actions will continue to
succeed, but (3) sb->s_fs_info will be NULL for the sb corresponding to
the deceased ipc_ns:1.
To make this happen, we must protect the ipc reference count when
a) a task exits and drops its ipcns->count, since it might be dropping
it to 0 and freeing the ipcns
b) a task accesses the ipcns through its mqueuefs interface, since it
bumps the ipcns refcount and might race with the last task in the ipcns
exiting.
So the kref is changed to an atomic_t so we can use
atomic_dec_and_lock(&ns->count,mq_lock), and every access to the ipcns
through ns = mqueuefs_sb->s_fs_info is protected by the same lock.
Signed-off-by: Cedric Le Goater <clg@fr.ibm.com>
Signed-off-by: Serge E. Hallyn <serue@us.ibm.com>
Cc: Alexey Dobriyan <adobriyan@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-06 20:01:10 -06:00
|
|
|
atomic_inc(&ns->count);
|
2008-02-08 05:18:22 -07:00
|
|
|
return ns;
|
|
|
|
}
|
|
|
|
|
namespaces: ipc namespaces: implement support for posix msqueues
Implement multiple mounts of the mqueue file system, and link it to usage
of CLONE_NEWIPC.
Each ipc ns has a corresponding mqueuefs superblock. When a user does
clone(CLONE_NEWIPC) or unshare(CLONE_NEWIPC), the unshare will cause an
internal mount of a new mqueuefs sb linked to the new ipc ns.
When a user does 'mount -t mqueue mqueue /dev/mqueue', he mounts the
mqueuefs superblock.
Posix message queues can be worked with both through the mq_* system calls
(see mq_overview(7)), and through the VFS through the mqueue mount. Any
usage of mq_open() and friends will work with the acting task's ipc
namespace. Any actions through the VFS will work with the mqueuefs in
which the file was created. So if a user doesn't remount mqueuefs after
unshare(CLONE_NEWIPC), mq_open("/ab") will not be reflected in "ls
/dev/mqueue".
If task a mounts mqueue for ipc_ns:1, then clones task b with a new ipcns,
ipcns:2, and then task a is the last task in ipc_ns:1 to exit, then (1)
ipc_ns:1 will be freed, (2) it's superblock will live on until task b
umounts the corresponding mqueuefs, and vfs actions will continue to
succeed, but (3) sb->s_fs_info will be NULL for the sb corresponding to
the deceased ipc_ns:1.
To make this happen, we must protect the ipc reference count when
a) a task exits and drops its ipcns->count, since it might be dropping
it to 0 and freeing the ipcns
b) a task accesses the ipcns through its mqueuefs interface, since it
bumps the ipcns refcount and might race with the last task in the ipcns
exiting.
So the kref is changed to an atomic_t so we can use
atomic_dec_and_lock(&ns->count,mq_lock), and every access to the ipcns
through ns = mqueuefs_sb->s_fs_info is protected by the same lock.
Signed-off-by: Cedric Le Goater <clg@fr.ibm.com>
Signed-off-by: Serge E. Hallyn <serue@us.ibm.com>
Cc: Alexey Dobriyan <adobriyan@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-06 20:01:10 -06:00
|
|
|
extern void put_ipc_ns(struct ipc_namespace *ns);
|
2008-02-08 05:18:22 -07:00
|
|
|
#else
|
|
|
|
static inline struct ipc_namespace *copy_ipcs(unsigned long flags,
|
2011-03-23 17:43:24 -06:00
|
|
|
struct task_struct *tsk)
|
2008-02-08 05:18:22 -07:00
|
|
|
{
|
|
|
|
if (flags & CLONE_NEWIPC)
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
2011-03-23 17:43:24 -06:00
|
|
|
return tsk->nsproxy->ipc_ns;
|
2008-02-08 05:18:22 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct ipc_namespace *get_ipc_ns(struct ipc_namespace *ns)
|
|
|
|
{
|
|
|
|
return ns;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void put_ipc_ns(struct ipc_namespace *ns)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
2009-04-06 20:01:11 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_POSIX_MQUEUE_SYSCTL
|
|
|
|
|
|
|
|
struct ctl_table_header;
|
|
|
|
extern struct ctl_table_header *mq_register_sysctl_table(void);
|
|
|
|
|
|
|
|
#else /* CONFIG_POSIX_MQUEUE_SYSCTL */
|
|
|
|
|
|
|
|
static inline struct ctl_table_header *mq_register_sysctl_table(void)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_POSIX_MQUEUE_SYSCTL */
|
2008-02-08 05:18:22 -07:00
|
|
|
#endif
|