2 * POSIX message queues filesystem for Linux.
4 * Copyright (C) 2003,2004 Krzysztof Benedyczak (golbi@mat.uni.torun.pl)
5 * Michal Wronski (michal.wronski@gmail.com)
7 * Spinlocks: Mohamed Abbas (abbas.mohamed@intel.com)
8 * Lockless receive & send, fd based notify:
9 * Manfred Spraul (manfred@colorfullife.com)
11 * Audit: George Wilson (ltcgcw@us.ibm.com)
13 * This file is released under the GPL.
16 #include <linux/capability.h>
17 #include <linux/init.h>
18 #include <linux/pagemap.h>
19 #include <linux/file.h>
20 #include <linux/mount.h>
21 #include <linux/namei.h>
22 #include <linux/sysctl.h>
23 #include <linux/poll.h>
24 #include <linux/mqueue.h>
25 #include <linux/msg.h>
26 #include <linux/skbuff.h>
27 #include <linux/vmalloc.h>
28 #include <linux/netlink.h>
29 #include <linux/syscalls.h>
30 #include <linux/audit.h>
31 #include <linux/signal.h>
32 #include <linux/mutex.h>
33 #include <linux/nsproxy.h>
34 #include <linux/pid.h>
35 #include <linux/ipc_namespace.h>
36 #include <linux/user_namespace.h>
37 #include <linux/slab.h>
42 #define MQUEUE_MAGIC 0x19800202
43 #define DIRENT_SIZE 20
44 #define FILENT_SIZE 80
50 #define STATE_PENDING 1
53 struct ext_wait_queue
{ /* queue of sleeping tasks */
54 struct task_struct
*task
;
55 struct list_head list
;
56 struct msg_msg
*msg
; /* ptr of loaded message */
57 int state
; /* one of STATE_* values */
60 struct mqueue_inode_info
{
62 struct inode vfs_inode
;
63 wait_queue_head_t wait_q
;
65 struct msg_msg
**messages
;
68 struct sigevent notify
;
69 struct pid
* notify_owner
;
70 struct user_namespace
*notify_user_ns
;
71 struct user_struct
*user
; /* user who created, for accounting */
72 struct sock
*notify_sock
;
73 struct sk_buff
*notify_cookie
;
75 /* for tasks waiting for free space and messages, respectively */
76 struct ext_wait_queue e_wait_q
[2];
78 unsigned long qsize
; /* size of queue in memory (sum of all msgs) */
81 static const struct inode_operations mqueue_dir_inode_operations
;
82 static const struct file_operations mqueue_file_operations
;
83 static const struct super_operations mqueue_super_ops
;
84 static void remove_notification(struct mqueue_inode_info
*info
);
86 static struct kmem_cache
*mqueue_inode_cachep
;
88 static struct ctl_table_header
* mq_sysctl_table
;
90 static inline struct mqueue_inode_info
*MQUEUE_I(struct inode
*inode
)
92 return container_of(inode
, struct mqueue_inode_info
, vfs_inode
);
96 * This routine should be called with the mq_lock held.
98 static inline struct ipc_namespace
*__get_ns_from_inode(struct inode
*inode
)
100 return get_ipc_ns(inode
->i_sb
->s_fs_info
);
103 static struct ipc_namespace
*get_ns_from_inode(struct inode
*inode
)
105 struct ipc_namespace
*ns
;
108 ns
= __get_ns_from_inode(inode
);
109 spin_unlock(&mq_lock
);
113 static struct inode
*mqueue_get_inode(struct super_block
*sb
,
114 struct ipc_namespace
*ipc_ns
, umode_t mode
,
115 struct mq_attr
*attr
)
117 struct user_struct
*u
= current_user();
121 inode
= new_inode(sb
);
125 inode
->i_ino
= get_next_ino();
126 inode
->i_mode
= mode
;
127 inode
->i_uid
= current_fsuid();
128 inode
->i_gid
= current_fsgid();
129 inode
->i_mtime
= inode
->i_ctime
= inode
->i_atime
= CURRENT_TIME
;
132 struct mqueue_inode_info
*info
;
133 unsigned long mq_bytes
, mq_msg_tblsz
;
135 inode
->i_fop
= &mqueue_file_operations
;
136 inode
->i_size
= FILENT_SIZE
;
137 /* mqueue specific info */
138 info
= MQUEUE_I(inode
);
139 spin_lock_init(&info
->lock
);
140 init_waitqueue_head(&info
->wait_q
);
141 INIT_LIST_HEAD(&info
->e_wait_q
[0].list
);
142 INIT_LIST_HEAD(&info
->e_wait_q
[1].list
);
143 info
->notify_owner
= NULL
;
144 info
->notify_user_ns
= NULL
;
146 info
->user
= NULL
; /* set when all is ok */
147 memset(&info
->attr
, 0, sizeof(info
->attr
));
148 info
->attr
.mq_maxmsg
= min(ipc_ns
->mq_msg_max
,
149 ipc_ns
->mq_msg_default
);
150 info
->attr
.mq_msgsize
= min(ipc_ns
->mq_msgsize_max
,
151 ipc_ns
->mq_msgsize_default
);
153 info
->attr
.mq_maxmsg
= attr
->mq_maxmsg
;
154 info
->attr
.mq_msgsize
= attr
->mq_msgsize
;
156 mq_msg_tblsz
= info
->attr
.mq_maxmsg
* sizeof(struct msg_msg
*);
157 if (mq_msg_tblsz
> PAGE_SIZE
)
158 info
->messages
= vmalloc(mq_msg_tblsz
);
160 info
->messages
= kmalloc(mq_msg_tblsz
, GFP_KERNEL
);
164 mq_bytes
= (mq_msg_tblsz
+
165 (info
->attr
.mq_maxmsg
* info
->attr
.mq_msgsize
));
168 if (u
->mq_bytes
+ mq_bytes
< u
->mq_bytes
||
169 u
->mq_bytes
+ mq_bytes
> rlimit(RLIMIT_MSGQUEUE
)) {
170 spin_unlock(&mq_lock
);
171 /* mqueue_evict_inode() releases info->messages */
175 u
->mq_bytes
+= mq_bytes
;
176 spin_unlock(&mq_lock
);
179 info
->user
= get_uid(u
);
180 } else if (S_ISDIR(mode
)) {
182 /* Some things misbehave if size == 0 on a directory */
183 inode
->i_size
= 2 * DIRENT_SIZE
;
184 inode
->i_op
= &mqueue_dir_inode_operations
;
185 inode
->i_fop
= &simple_dir_operations
;
195 static int mqueue_fill_super(struct super_block
*sb
, void *data
, int silent
)
198 struct ipc_namespace
*ns
= data
;
200 sb
->s_blocksize
= PAGE_CACHE_SIZE
;
201 sb
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
202 sb
->s_magic
= MQUEUE_MAGIC
;
203 sb
->s_op
= &mqueue_super_ops
;
205 inode
= mqueue_get_inode(sb
, ns
, S_IFDIR
| S_ISVTX
| S_IRWXUGO
, NULL
);
207 return PTR_ERR(inode
);
209 sb
->s_root
= d_make_root(inode
);
215 static struct dentry
*mqueue_mount(struct file_system_type
*fs_type
,
216 int flags
, const char *dev_name
,
219 if (!(flags
& MS_KERNMOUNT
))
220 data
= current
->nsproxy
->ipc_ns
;
221 return mount_ns(fs_type
, flags
, data
, mqueue_fill_super
);
224 static void init_once(void *foo
)
226 struct mqueue_inode_info
*p
= (struct mqueue_inode_info
*) foo
;
228 inode_init_once(&p
->vfs_inode
);
231 static struct inode
*mqueue_alloc_inode(struct super_block
*sb
)
233 struct mqueue_inode_info
*ei
;
235 ei
= kmem_cache_alloc(mqueue_inode_cachep
, GFP_KERNEL
);
238 return &ei
->vfs_inode
;
241 static void mqueue_i_callback(struct rcu_head
*head
)
243 struct inode
*inode
= container_of(head
, struct inode
, i_rcu
);
244 kmem_cache_free(mqueue_inode_cachep
, MQUEUE_I(inode
));
247 static void mqueue_destroy_inode(struct inode
*inode
)
249 call_rcu(&inode
->i_rcu
, mqueue_i_callback
);
252 static void mqueue_evict_inode(struct inode
*inode
)
254 struct mqueue_inode_info
*info
;
255 struct user_struct
*user
;
256 unsigned long mq_bytes
;
258 struct ipc_namespace
*ipc_ns
;
262 if (S_ISDIR(inode
->i_mode
))
265 ipc_ns
= get_ns_from_inode(inode
);
266 info
= MQUEUE_I(inode
);
267 spin_lock(&info
->lock
);
268 for (i
= 0; i
< info
->attr
.mq_curmsgs
; i
++)
269 free_msg(info
->messages
[i
]);
270 if (is_vmalloc_addr(info
->messages
))
271 vfree(info
->messages
);
273 kfree(info
->messages
);
274 spin_unlock(&info
->lock
);
276 /* Total amount of bytes accounted for the mqueue */
277 mq_bytes
= info
->attr
.mq_maxmsg
* (sizeof(struct msg_msg
*)
278 + info
->attr
.mq_msgsize
);
282 user
->mq_bytes
-= mq_bytes
;
284 * get_ns_from_inode() ensures that the
285 * (ipc_ns = sb->s_fs_info) is either a valid ipc_ns
286 * to which we now hold a reference, or it is NULL.
287 * We can't put it here under mq_lock, though.
290 ipc_ns
->mq_queues_count
--;
291 spin_unlock(&mq_lock
);
298 static int mqueue_create(struct inode
*dir
, struct dentry
*dentry
,
299 umode_t mode
, struct nameidata
*nd
)
302 struct mq_attr
*attr
= dentry
->d_fsdata
;
304 struct ipc_namespace
*ipc_ns
;
307 ipc_ns
= __get_ns_from_inode(dir
);
312 if (ipc_ns
->mq_queues_count
>= HARD_QUEUESMAX
||
313 (ipc_ns
->mq_queues_count
>= ipc_ns
->mq_queues_max
&&
314 !capable(CAP_SYS_RESOURCE
))) {
318 ipc_ns
->mq_queues_count
++;
319 spin_unlock(&mq_lock
);
321 inode
= mqueue_get_inode(dir
->i_sb
, ipc_ns
, mode
, attr
);
323 error
= PTR_ERR(inode
);
325 ipc_ns
->mq_queues_count
--;
330 dir
->i_size
+= DIRENT_SIZE
;
331 dir
->i_ctime
= dir
->i_mtime
= dir
->i_atime
= CURRENT_TIME
;
333 d_instantiate(dentry
, inode
);
337 spin_unlock(&mq_lock
);
343 static int mqueue_unlink(struct inode
*dir
, struct dentry
*dentry
)
345 struct inode
*inode
= dentry
->d_inode
;
347 dir
->i_ctime
= dir
->i_mtime
= dir
->i_atime
= CURRENT_TIME
;
348 dir
->i_size
-= DIRENT_SIZE
;
355 * This is routine for system read from queue file.
356 * To avoid mess with doing here some sort of mq_receive we allow
357 * to read only queue size & notification info (the only values
358 * that are interesting from user point of view and aren't accessible
359 * through std routines)
361 static ssize_t
mqueue_read_file(struct file
*filp
, char __user
*u_data
,
362 size_t count
, loff_t
*off
)
364 struct mqueue_inode_info
*info
= MQUEUE_I(filp
->f_path
.dentry
->d_inode
);
365 char buffer
[FILENT_SIZE
];
368 spin_lock(&info
->lock
);
369 snprintf(buffer
, sizeof(buffer
),
370 "QSIZE:%-10lu NOTIFY:%-5d SIGNO:%-5d NOTIFY_PID:%-6d\n",
372 info
->notify_owner
? info
->notify
.sigev_notify
: 0,
373 (info
->notify_owner
&&
374 info
->notify
.sigev_notify
== SIGEV_SIGNAL
) ?
375 info
->notify
.sigev_signo
: 0,
376 pid_vnr(info
->notify_owner
));
377 spin_unlock(&info
->lock
);
378 buffer
[sizeof(buffer
)-1] = '\0';
380 ret
= simple_read_from_buffer(u_data
, count
, off
, buffer
,
385 filp
->f_path
.dentry
->d_inode
->i_atime
= filp
->f_path
.dentry
->d_inode
->i_ctime
= CURRENT_TIME
;
389 static int mqueue_flush_file(struct file
*filp
, fl_owner_t id
)
391 struct mqueue_inode_info
*info
= MQUEUE_I(filp
->f_path
.dentry
->d_inode
);
393 spin_lock(&info
->lock
);
394 if (task_tgid(current
) == info
->notify_owner
)
395 remove_notification(info
);
397 spin_unlock(&info
->lock
);
401 static unsigned int mqueue_poll_file(struct file
*filp
, struct poll_table_struct
*poll_tab
)
403 struct mqueue_inode_info
*info
= MQUEUE_I(filp
->f_path
.dentry
->d_inode
);
406 poll_wait(filp
, &info
->wait_q
, poll_tab
);
408 spin_lock(&info
->lock
);
409 if (info
->attr
.mq_curmsgs
)
410 retval
= POLLIN
| POLLRDNORM
;
412 if (info
->attr
.mq_curmsgs
< info
->attr
.mq_maxmsg
)
413 retval
|= POLLOUT
| POLLWRNORM
;
414 spin_unlock(&info
->lock
);
419 /* Adds current to info->e_wait_q[sr] before element with smaller prio */
420 static void wq_add(struct mqueue_inode_info
*info
, int sr
,
421 struct ext_wait_queue
*ewp
)
423 struct ext_wait_queue
*walk
;
427 list_for_each_entry(walk
, &info
->e_wait_q
[sr
].list
, list
) {
428 if (walk
->task
->static_prio
<= current
->static_prio
) {
429 list_add_tail(&ewp
->list
, &walk
->list
);
433 list_add_tail(&ewp
->list
, &info
->e_wait_q
[sr
].list
);
437 * Puts current task to sleep. Caller must hold queue lock. After return
441 static int wq_sleep(struct mqueue_inode_info
*info
, int sr
,
442 ktime_t
*timeout
, struct ext_wait_queue
*ewp
)
447 wq_add(info
, sr
, ewp
);
450 set_current_state(TASK_INTERRUPTIBLE
);
452 spin_unlock(&info
->lock
);
453 time
= schedule_hrtimeout_range_clock(timeout
, 0,
454 HRTIMER_MODE_ABS
, CLOCK_REALTIME
);
456 while (ewp
->state
== STATE_PENDING
)
459 if (ewp
->state
== STATE_READY
) {
463 spin_lock(&info
->lock
);
464 if (ewp
->state
== STATE_READY
) {
468 if (signal_pending(current
)) {
469 retval
= -ERESTARTSYS
;
477 list_del(&ewp
->list
);
479 spin_unlock(&info
->lock
);
485 * Returns waiting task that should be serviced first or NULL if none exists
487 static struct ext_wait_queue
*wq_get_first_waiter(
488 struct mqueue_inode_info
*info
, int sr
)
490 struct list_head
*ptr
;
492 ptr
= info
->e_wait_q
[sr
].list
.prev
;
493 if (ptr
== &info
->e_wait_q
[sr
].list
)
495 return list_entry(ptr
, struct ext_wait_queue
, list
);
498 /* Auxiliary functions to manipulate messages' list */
499 static void msg_insert(struct msg_msg
*ptr
, struct mqueue_inode_info
*info
)
503 k
= info
->attr
.mq_curmsgs
- 1;
504 while (k
>= 0 && info
->messages
[k
]->m_type
>= ptr
->m_type
) {
505 info
->messages
[k
+ 1] = info
->messages
[k
];
508 info
->attr
.mq_curmsgs
++;
509 info
->qsize
+= ptr
->m_ts
;
510 info
->messages
[k
+ 1] = ptr
;
513 static inline struct msg_msg
*msg_get(struct mqueue_inode_info
*info
)
515 info
->qsize
-= info
->messages
[--info
->attr
.mq_curmsgs
]->m_ts
;
516 return info
->messages
[info
->attr
.mq_curmsgs
];
519 static inline void set_cookie(struct sk_buff
*skb
, char code
)
521 ((char*)skb
->data
)[NOTIFY_COOKIE_LEN
-1] = code
;
525 * The next function is only to split too long sys_mq_timedsend
527 static void __do_notify(struct mqueue_inode_info
*info
)
530 * invoked when there is registered process and there isn't process
531 * waiting synchronously for message AND state of queue changed from
532 * empty to not empty. Here we are sure that no one is waiting
534 if (info
->notify_owner
&&
535 info
->attr
.mq_curmsgs
== 1) {
536 struct siginfo sig_i
;
537 switch (info
->notify
.sigev_notify
) {
543 sig_i
.si_signo
= info
->notify
.sigev_signo
;
545 sig_i
.si_code
= SI_MESGQ
;
546 sig_i
.si_value
= info
->notify
.sigev_value
;
547 /* map current pid/uid into info->owner's namespaces */
549 sig_i
.si_pid
= task_tgid_nr_ns(current
,
550 ns_of_pid(info
->notify_owner
));
551 sig_i
.si_uid
= from_kuid_munged(info
->notify_user_ns
, current_uid());
554 kill_pid_info(info
->notify
.sigev_signo
,
555 &sig_i
, info
->notify_owner
);
558 set_cookie(info
->notify_cookie
, NOTIFY_WOKENUP
);
559 netlink_sendskb(info
->notify_sock
, info
->notify_cookie
);
562 /* after notification unregisters process */
563 put_pid(info
->notify_owner
);
564 put_user_ns(info
->notify_user_ns
);
565 info
->notify_owner
= NULL
;
566 info
->notify_user_ns
= NULL
;
568 wake_up(&info
->wait_q
);
571 static int prepare_timeout(const struct timespec __user
*u_abs_timeout
,
572 ktime_t
*expires
, struct timespec
*ts
)
574 if (copy_from_user(ts
, u_abs_timeout
, sizeof(struct timespec
)))
576 if (!timespec_valid(ts
))
579 *expires
= timespec_to_ktime(*ts
);
583 static void remove_notification(struct mqueue_inode_info
*info
)
585 if (info
->notify_owner
!= NULL
&&
586 info
->notify
.sigev_notify
== SIGEV_THREAD
) {
587 set_cookie(info
->notify_cookie
, NOTIFY_REMOVED
);
588 netlink_sendskb(info
->notify_sock
, info
->notify_cookie
);
590 put_pid(info
->notify_owner
);
591 put_user_ns(info
->notify_user_ns
);
592 info
->notify_owner
= NULL
;
593 info
->notify_user_ns
= NULL
;
596 static int mq_attr_ok(struct ipc_namespace
*ipc_ns
, struct mq_attr
*attr
)
598 if (attr
->mq_maxmsg
<= 0 || attr
->mq_msgsize
<= 0)
600 if (capable(CAP_SYS_RESOURCE
)) {
601 if (attr
->mq_maxmsg
> HARD_MSGMAX
||
602 attr
->mq_msgsize
> HARD_MSGSIZEMAX
)
605 if (attr
->mq_maxmsg
> ipc_ns
->mq_msg_max
||
606 attr
->mq_msgsize
> ipc_ns
->mq_msgsize_max
)
609 /* check for overflow */
610 if (attr
->mq_msgsize
> ULONG_MAX
/attr
->mq_maxmsg
)
612 if ((unsigned long)(attr
->mq_maxmsg
* (attr
->mq_msgsize
613 + sizeof (struct msg_msg
*))) <
614 (unsigned long)(attr
->mq_maxmsg
* attr
->mq_msgsize
))
620 * Invoked when creating a new queue via sys_mq_open
622 static struct file
*do_create(struct ipc_namespace
*ipc_ns
, struct dentry
*dir
,
623 struct dentry
*dentry
, int oflag
, umode_t mode
,
624 struct mq_attr
*attr
)
626 const struct cred
*cred
= current_cred();
631 if (!mq_attr_ok(ipc_ns
, attr
)) {
635 /* store for use during create */
636 dentry
->d_fsdata
= attr
;
639 mode
&= ~current_umask();
640 ret
= mnt_want_write(ipc_ns
->mq_mnt
);
643 ret
= vfs_create(dir
->d_inode
, dentry
, mode
, NULL
);
644 dentry
->d_fsdata
= NULL
;
648 result
= dentry_open(dentry
, ipc_ns
->mq_mnt
, oflag
, cred
);
650 * dentry_open() took a persistent mnt_want_write(),
651 * so we can now drop this one.
653 mnt_drop_write(ipc_ns
->mq_mnt
);
657 mnt_drop_write(ipc_ns
->mq_mnt
);
660 mntput(ipc_ns
->mq_mnt
);
664 /* Opens existing queue */
665 static struct file
*do_open(struct ipc_namespace
*ipc_ns
,
666 struct dentry
*dentry
, int oflag
)
669 const struct cred
*cred
= current_cred();
671 static const int oflag2acc
[O_ACCMODE
] = { MAY_READ
, MAY_WRITE
,
672 MAY_READ
| MAY_WRITE
};
674 if ((oflag
& O_ACCMODE
) == (O_RDWR
| O_WRONLY
)) {
679 if (inode_permission(dentry
->d_inode
, oflag2acc
[oflag
& O_ACCMODE
])) {
684 return dentry_open(dentry
, ipc_ns
->mq_mnt
, oflag
, cred
);
688 mntput(ipc_ns
->mq_mnt
);
692 SYSCALL_DEFINE4(mq_open
, const char __user
*, u_name
, int, oflag
, umode_t
, mode
,
693 struct mq_attr __user
*, u_attr
)
695 struct dentry
*dentry
;
700 struct ipc_namespace
*ipc_ns
= current
->nsproxy
->ipc_ns
;
702 if (u_attr
&& copy_from_user(&attr
, u_attr
, sizeof(struct mq_attr
)))
705 audit_mq_open(oflag
, mode
, u_attr
? &attr
: NULL
);
707 if (IS_ERR(name
= getname(u_name
)))
708 return PTR_ERR(name
);
710 fd
= get_unused_fd_flags(O_CLOEXEC
);
714 mutex_lock(&ipc_ns
->mq_mnt
->mnt_root
->d_inode
->i_mutex
);
715 dentry
= lookup_one_len(name
, ipc_ns
->mq_mnt
->mnt_root
, strlen(name
));
716 if (IS_ERR(dentry
)) {
717 error
= PTR_ERR(dentry
);
720 mntget(ipc_ns
->mq_mnt
);
722 if (oflag
& O_CREAT
) {
723 if (dentry
->d_inode
) { /* entry already exists */
724 audit_inode(name
, dentry
);
725 if (oflag
& O_EXCL
) {
729 filp
= do_open(ipc_ns
, dentry
, oflag
);
731 filp
= do_create(ipc_ns
, ipc_ns
->mq_mnt
->mnt_root
,
733 u_attr
? &attr
: NULL
);
736 if (!dentry
->d_inode
) {
740 audit_inode(name
, dentry
);
741 filp
= do_open(ipc_ns
, dentry
, oflag
);
745 error
= PTR_ERR(filp
);
749 fd_install(fd
, filp
);
754 mntput(ipc_ns
->mq_mnt
);
759 mutex_unlock(&ipc_ns
->mq_mnt
->mnt_root
->d_inode
->i_mutex
);
765 SYSCALL_DEFINE1(mq_unlink
, const char __user
*, u_name
)
769 struct dentry
*dentry
;
770 struct inode
*inode
= NULL
;
771 struct ipc_namespace
*ipc_ns
= current
->nsproxy
->ipc_ns
;
773 name
= getname(u_name
);
775 return PTR_ERR(name
);
777 mutex_lock_nested(&ipc_ns
->mq_mnt
->mnt_root
->d_inode
->i_mutex
,
779 dentry
= lookup_one_len(name
, ipc_ns
->mq_mnt
->mnt_root
, strlen(name
));
780 if (IS_ERR(dentry
)) {
781 err
= PTR_ERR(dentry
);
785 if (!dentry
->d_inode
) {
790 inode
= dentry
->d_inode
;
793 err
= mnt_want_write(ipc_ns
->mq_mnt
);
796 err
= vfs_unlink(dentry
->d_parent
->d_inode
, dentry
);
797 mnt_drop_write(ipc_ns
->mq_mnt
);
802 mutex_unlock(&ipc_ns
->mq_mnt
->mnt_root
->d_inode
->i_mutex
);
810 /* Pipelined send and receive functions.
812 * If a receiver finds no waiting message, then it registers itself in the
813 * list of waiting receivers. A sender checks that list before adding the new
814 * message into the message array. If there is a waiting receiver, then it
815 * bypasses the message array and directly hands the message over to the
817 * The receiver accepts the message and returns without grabbing the queue
818 * spinlock. Therefore an intermediate STATE_PENDING state and memory barriers
819 * are necessary. The same algorithm is used for sysv semaphores, see
820 * ipc/sem.c for more details.
822 * The same algorithm is used for senders.
825 /* pipelined_send() - send a message directly to the task waiting in
826 * sys_mq_timedreceive() (without inserting message into a queue).
828 static inline void pipelined_send(struct mqueue_inode_info
*info
,
829 struct msg_msg
*message
,
830 struct ext_wait_queue
*receiver
)
832 receiver
->msg
= message
;
833 list_del(&receiver
->list
);
834 receiver
->state
= STATE_PENDING
;
835 wake_up_process(receiver
->task
);
837 receiver
->state
= STATE_READY
;
840 /* pipelined_receive() - if there is task waiting in sys_mq_timedsend()
841 * gets its message and put to the queue (we have one free place for sure). */
842 static inline void pipelined_receive(struct mqueue_inode_info
*info
)
844 struct ext_wait_queue
*sender
= wq_get_first_waiter(info
, SEND
);
848 wake_up_interruptible(&info
->wait_q
);
851 msg_insert(sender
->msg
, info
);
852 list_del(&sender
->list
);
853 sender
->state
= STATE_PENDING
;
854 wake_up_process(sender
->task
);
856 sender
->state
= STATE_READY
;
859 SYSCALL_DEFINE5(mq_timedsend
, mqd_t
, mqdes
, const char __user
*, u_msg_ptr
,
860 size_t, msg_len
, unsigned int, msg_prio
,
861 const struct timespec __user
*, u_abs_timeout
)
865 struct ext_wait_queue wait
;
866 struct ext_wait_queue
*receiver
;
867 struct msg_msg
*msg_ptr
;
868 struct mqueue_inode_info
*info
;
869 ktime_t expires
, *timeout
= NULL
;
874 int res
= prepare_timeout(u_abs_timeout
, &expires
, &ts
);
880 if (unlikely(msg_prio
>= (unsigned long) MQ_PRIO_MAX
))
883 audit_mq_sendrecv(mqdes
, msg_len
, msg_prio
, timeout
? &ts
: NULL
);
886 if (unlikely(!filp
)) {
891 inode
= filp
->f_path
.dentry
->d_inode
;
892 if (unlikely(filp
->f_op
!= &mqueue_file_operations
)) {
896 info
= MQUEUE_I(inode
);
897 audit_inode(NULL
, filp
->f_path
.dentry
);
899 if (unlikely(!(filp
->f_mode
& FMODE_WRITE
))) {
904 if (unlikely(msg_len
> info
->attr
.mq_msgsize
)) {
909 /* First try to allocate memory, before doing anything with
910 * existing queues. */
911 msg_ptr
= load_msg(u_msg_ptr
, msg_len
);
912 if (IS_ERR(msg_ptr
)) {
913 ret
= PTR_ERR(msg_ptr
);
916 msg_ptr
->m_ts
= msg_len
;
917 msg_ptr
->m_type
= msg_prio
;
919 spin_lock(&info
->lock
);
921 if (info
->attr
.mq_curmsgs
== info
->attr
.mq_maxmsg
) {
922 if (filp
->f_flags
& O_NONBLOCK
) {
923 spin_unlock(&info
->lock
);
927 wait
.msg
= (void *) msg_ptr
;
928 wait
.state
= STATE_NONE
;
929 ret
= wq_sleep(info
, SEND
, timeout
, &wait
);
934 receiver
= wq_get_first_waiter(info
, RECV
);
936 pipelined_send(info
, msg_ptr
, receiver
);
938 /* adds message to the queue */
939 msg_insert(msg_ptr
, info
);
942 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
=
944 spin_unlock(&info
->lock
);
953 SYSCALL_DEFINE5(mq_timedreceive
, mqd_t
, mqdes
, char __user
*, u_msg_ptr
,
954 size_t, msg_len
, unsigned int __user
*, u_msg_prio
,
955 const struct timespec __user
*, u_abs_timeout
)
958 struct msg_msg
*msg_ptr
;
961 struct mqueue_inode_info
*info
;
962 struct ext_wait_queue wait
;
963 ktime_t expires
, *timeout
= NULL
;
967 int res
= prepare_timeout(u_abs_timeout
, &expires
, &ts
);
973 audit_mq_sendrecv(mqdes
, msg_len
, 0, timeout
? &ts
: NULL
);
976 if (unlikely(!filp
)) {
981 inode
= filp
->f_path
.dentry
->d_inode
;
982 if (unlikely(filp
->f_op
!= &mqueue_file_operations
)) {
986 info
= MQUEUE_I(inode
);
987 audit_inode(NULL
, filp
->f_path
.dentry
);
989 if (unlikely(!(filp
->f_mode
& FMODE_READ
))) {
994 /* checks if buffer is big enough */
995 if (unlikely(msg_len
< info
->attr
.mq_msgsize
)) {
1000 spin_lock(&info
->lock
);
1001 if (info
->attr
.mq_curmsgs
== 0) {
1002 if (filp
->f_flags
& O_NONBLOCK
) {
1003 spin_unlock(&info
->lock
);
1006 wait
.task
= current
;
1007 wait
.state
= STATE_NONE
;
1008 ret
= wq_sleep(info
, RECV
, timeout
, &wait
);
1012 msg_ptr
= msg_get(info
);
1014 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
=
1017 /* There is now free space in queue. */
1018 pipelined_receive(info
);
1019 spin_unlock(&info
->lock
);
1023 ret
= msg_ptr
->m_ts
;
1025 if ((u_msg_prio
&& put_user(msg_ptr
->m_type
, u_msg_prio
)) ||
1026 store_msg(u_msg_ptr
, msg_ptr
, msg_ptr
->m_ts
)) {
1038 * Notes: the case when user wants us to deregister (with NULL as pointer)
1039 * and he isn't currently owner of notification, will be silently discarded.
1040 * It isn't explicitly defined in the POSIX.
1042 SYSCALL_DEFINE2(mq_notify
, mqd_t
, mqdes
,
1043 const struct sigevent __user
*, u_notification
)
1048 struct inode
*inode
;
1049 struct sigevent notification
;
1050 struct mqueue_inode_info
*info
;
1053 if (u_notification
) {
1054 if (copy_from_user(¬ification
, u_notification
,
1055 sizeof(struct sigevent
)))
1059 audit_mq_notify(mqdes
, u_notification
? ¬ification
: NULL
);
1063 if (u_notification
!= NULL
) {
1064 if (unlikely(notification
.sigev_notify
!= SIGEV_NONE
&&
1065 notification
.sigev_notify
!= SIGEV_SIGNAL
&&
1066 notification
.sigev_notify
!= SIGEV_THREAD
))
1068 if (notification
.sigev_notify
== SIGEV_SIGNAL
&&
1069 !valid_signal(notification
.sigev_signo
)) {
1072 if (notification
.sigev_notify
== SIGEV_THREAD
) {
1075 /* create the notify skb */
1076 nc
= alloc_skb(NOTIFY_COOKIE_LEN
, GFP_KERNEL
);
1081 if (copy_from_user(nc
->data
,
1082 notification
.sigev_value
.sival_ptr
,
1083 NOTIFY_COOKIE_LEN
)) {
1088 /* TODO: add a header? */
1089 skb_put(nc
, NOTIFY_COOKIE_LEN
);
1090 /* and attach it to the socket */
1092 filp
= fget(notification
.sigev_signo
);
1097 sock
= netlink_getsockbyfilp(filp
);
1100 ret
= PTR_ERR(sock
);
1105 timeo
= MAX_SCHEDULE_TIMEOUT
;
1106 ret
= netlink_attachskb(sock
, nc
, &timeo
, NULL
);
1123 inode
= filp
->f_path
.dentry
->d_inode
;
1124 if (unlikely(filp
->f_op
!= &mqueue_file_operations
)) {
1128 info
= MQUEUE_I(inode
);
1131 spin_lock(&info
->lock
);
1132 if (u_notification
== NULL
) {
1133 if (info
->notify_owner
== task_tgid(current
)) {
1134 remove_notification(info
);
1135 inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME
;
1137 } else if (info
->notify_owner
!= NULL
) {
1140 switch (notification
.sigev_notify
) {
1142 info
->notify
.sigev_notify
= SIGEV_NONE
;
1145 info
->notify_sock
= sock
;
1146 info
->notify_cookie
= nc
;
1149 info
->notify
.sigev_notify
= SIGEV_THREAD
;
1152 info
->notify
.sigev_signo
= notification
.sigev_signo
;
1153 info
->notify
.sigev_value
= notification
.sigev_value
;
1154 info
->notify
.sigev_notify
= SIGEV_SIGNAL
;
1158 info
->notify_owner
= get_pid(task_tgid(current
));
1159 info
->notify_user_ns
= get_user_ns(current_user_ns());
1160 inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME
;
1162 spin_unlock(&info
->lock
);
1167 netlink_detachskb(sock
, nc
);
1174 SYSCALL_DEFINE3(mq_getsetattr
, mqd_t
, mqdes
,
1175 const struct mq_attr __user
*, u_mqstat
,
1176 struct mq_attr __user
*, u_omqstat
)
1179 struct mq_attr mqstat
, omqstat
;
1181 struct inode
*inode
;
1182 struct mqueue_inode_info
*info
;
1184 if (u_mqstat
!= NULL
) {
1185 if (copy_from_user(&mqstat
, u_mqstat
, sizeof(struct mq_attr
)))
1187 if (mqstat
.mq_flags
& (~O_NONBLOCK
))
1197 inode
= filp
->f_path
.dentry
->d_inode
;
1198 if (unlikely(filp
->f_op
!= &mqueue_file_operations
)) {
1202 info
= MQUEUE_I(inode
);
1204 spin_lock(&info
->lock
);
1206 omqstat
= info
->attr
;
1207 omqstat
.mq_flags
= filp
->f_flags
& O_NONBLOCK
;
1209 audit_mq_getsetattr(mqdes
, &mqstat
);
1210 spin_lock(&filp
->f_lock
);
1211 if (mqstat
.mq_flags
& O_NONBLOCK
)
1212 filp
->f_flags
|= O_NONBLOCK
;
1214 filp
->f_flags
&= ~O_NONBLOCK
;
1215 spin_unlock(&filp
->f_lock
);
1217 inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME
;
1220 spin_unlock(&info
->lock
);
1223 if (u_omqstat
!= NULL
&& copy_to_user(u_omqstat
, &omqstat
,
1224 sizeof(struct mq_attr
)))
1233 static const struct inode_operations mqueue_dir_inode_operations
= {
1234 .lookup
= simple_lookup
,
1235 .create
= mqueue_create
,
1236 .unlink
= mqueue_unlink
,
1239 static const struct file_operations mqueue_file_operations
= {
1240 .flush
= mqueue_flush_file
,
1241 .poll
= mqueue_poll_file
,
1242 .read
= mqueue_read_file
,
1243 .llseek
= default_llseek
,
1246 static const struct super_operations mqueue_super_ops
= {
1247 .alloc_inode
= mqueue_alloc_inode
,
1248 .destroy_inode
= mqueue_destroy_inode
,
1249 .evict_inode
= mqueue_evict_inode
,
1250 .statfs
= simple_statfs
,
1253 static struct file_system_type mqueue_fs_type
= {
1255 .mount
= mqueue_mount
,
1256 .kill_sb
= kill_litter_super
,
1259 int mq_init_ns(struct ipc_namespace
*ns
)
1261 ns
->mq_queues_count
= 0;
1262 ns
->mq_queues_max
= DFLT_QUEUESMAX
;
1263 ns
->mq_msg_max
= DFLT_MSGMAX
;
1264 ns
->mq_msgsize_max
= DFLT_MSGSIZEMAX
;
1265 ns
->mq_msg_default
= DFLT_MSG
;
1266 ns
->mq_msgsize_default
= DFLT_MSGSIZE
;
1268 ns
->mq_mnt
= kern_mount_data(&mqueue_fs_type
, ns
);
1269 if (IS_ERR(ns
->mq_mnt
)) {
1270 int err
= PTR_ERR(ns
->mq_mnt
);
1277 void mq_clear_sbinfo(struct ipc_namespace
*ns
)
1279 ns
->mq_mnt
->mnt_sb
->s_fs_info
= NULL
;
1282 void mq_put_mnt(struct ipc_namespace
*ns
)
1284 kern_unmount(ns
->mq_mnt
);
1287 static int __init
init_mqueue_fs(void)
1291 mqueue_inode_cachep
= kmem_cache_create("mqueue_inode_cache",
1292 sizeof(struct mqueue_inode_info
), 0,
1293 SLAB_HWCACHE_ALIGN
, init_once
);
1294 if (mqueue_inode_cachep
== NULL
)
1297 /* ignore failures - they are not fatal */
1298 mq_sysctl_table
= mq_register_sysctl_table();
1300 error
= register_filesystem(&mqueue_fs_type
);
1304 spin_lock_init(&mq_lock
);
1306 error
= mq_init_ns(&init_ipc_ns
);
1308 goto out_filesystem
;
1313 unregister_filesystem(&mqueue_fs_type
);
1315 if (mq_sysctl_table
)
1316 unregister_sysctl_table(mq_sysctl_table
);
1317 kmem_cache_destroy(mqueue_inode_cachep
);
1321 __initcall(init_mqueue_fs
);