Lines Matching refs:info
70 * Accesses to a message queue are synchronized by acquiring info->lock.
74 * framework. info->lock is already released when wake_up_q is called.
77 * acquiring info->lock.
121 * to TASK_INTERRUPTIBLE: spin_unlock(&info->lock) provides the
123 * info->lock, i.e. spin_lock(&info->lock) provided a pairing
163 static void remove_notification(struct mqueue_inode_info *info);
191 static int msg_insert(struct msg_msg *msg, struct mqueue_inode_info *info)
197 p = &info->msg_tree.rb_node;
210 if (info->node_cache) {
211 leaf = info->node_cache;
212 info->node_cache = NULL;
222 info->msg_tree_rightmost = &leaf->rb_node;
225 rb_insert_color(&leaf->rb_node, &info->msg_tree);
227 info->attr.mq_curmsgs++;
228 info->qsize += msg->m_ts;
234 struct mqueue_inode_info *info)
238 if (info->msg_tree_rightmost == node)
239 info->msg_tree_rightmost = rb_prev(node);
241 rb_erase(node, &info->msg_tree);
242 if (info->node_cache)
245 info->node_cache = leaf;
248 static inline struct msg_msg *msg_get(struct mqueue_inode_info *info)
260 parent = info->msg_tree_rightmost;
262 if (info->attr.mq_curmsgs) {
266 info->attr.mq_curmsgs = 0;
275 msg_tree_erase(leaf, info);
282 msg_tree_erase(leaf, info);
285 info->attr.mq_curmsgs--;
286 info->qsize -= msg->m_ts;
308 struct mqueue_inode_info *info;
313 /* mqueue specific info */
314 info = MQUEUE_I(inode);
315 spin_lock_init(&info->lock);
316 init_waitqueue_head(&info->wait_q);
317 INIT_LIST_HEAD(&info->e_wait_q[0].list);
318 INIT_LIST_HEAD(&info->e_wait_q[1].list);
319 info->notify_owner = NULL;
320 info->notify_user_ns = NULL;
321 info->qsize = 0;
322 info->ucounts = NULL; /* set when all is ok */
323 info->msg_tree = RB_ROOT;
324 info->msg_tree_rightmost = NULL;
325 info->node_cache = NULL;
326 memset(&info->attr, 0, sizeof(info->attr));
327 info->attr.mq_maxmsg = min(ipc_ns->mq_msg_max,
329 info->attr.mq_msgsize = min(ipc_ns->mq_msgsize_max,
332 info->attr.mq_maxmsg = attr->mq_maxmsg;
333 info->attr.mq_msgsize = attr->mq_msgsize;
350 if (info->attr.mq_maxmsg <= 0 || info->attr.mq_msgsize <= 0)
353 if (info->attr.mq_maxmsg > HARD_MSGMAX ||
354 info->attr.mq_msgsize > HARD_MSGSIZEMAX)
357 if (info->attr.mq_maxmsg > ipc_ns->mq_msg_max ||
358 info->attr.mq_msgsize > ipc_ns->mq_msgsize_max)
363 if (info->attr.mq_msgsize > ULONG_MAX/info->attr.mq_maxmsg)
365 mq_treesize = info->attr.mq_maxmsg * sizeof(struct msg_msg) +
366 min_t(unsigned int, info->attr.mq_maxmsg, MQ_PRIO_MAX) *
368 mq_bytes = info->attr.mq_maxmsg * info->attr.mq_msgsize;
372 info->ucounts = get_ucounts(current_ucounts());
373 if (info->ucounts) {
377 msgqueue = inc_rlimit_ucounts(info->ucounts, UCOUNT_RLIMIT_MSGQUEUE, mq_bytes);
379 dec_rlimit_ucounts(info->ucounts, UCOUNT_RLIMIT_MSGQUEUE, mq_bytes);
381 put_ucounts(info->ucounts);
382 info->ucounts = NULL;
383 /* mqueue_evict_inode() releases info->messages */
514 struct mqueue_inode_info *info;
525 info = MQUEUE_I(inode);
526 spin_lock(&info->lock);
527 while ((msg = msg_get(info)) != NULL)
529 kfree(info->node_cache);
530 spin_unlock(&info->lock);
537 if (info->ucounts) {
541 mq_treesize = info->attr.mq_maxmsg * sizeof(struct msg_msg) +
542 min_t(unsigned int, info->attr.mq_maxmsg, MQ_PRIO_MAX) *
545 mq_bytes = mq_treesize + (info->attr.mq_maxmsg *
546 info->attr.mq_msgsize);
549 dec_rlimit_ucounts(info->ucounts, UCOUNT_RLIMIT_MSGQUEUE, mq_bytes);
559 put_ucounts(info->ucounts);
560 info->ucounts = NULL;
631 * to read only queue size & notification info (the only values
639 struct mqueue_inode_info *info = MQUEUE_I(inode);
643 spin_lock(&info->lock);
646 info->qsize,
647 info->notify_owner ? info->notify.sigev_notify : 0,
648 (info->notify_owner &&
649 info->notify.sigev_notify == SIGEV_SIGNAL) ?
650 info->notify.sigev_signo : 0,
651 pid_vnr(info->notify_owner));
652 spin_unlock(&info->lock);
666 struct mqueue_inode_info *info = MQUEUE_I(file_inode(filp));
668 spin_lock(&info->lock);
669 if (task_tgid(current) == info->notify_owner)
670 remove_notification(info);
672 spin_unlock(&info->lock);
678 struct mqueue_inode_info *info = MQUEUE_I(file_inode(filp));
681 poll_wait(filp, &info->wait_q, poll_tab);
683 spin_lock(&info->lock);
684 if (info->attr.mq_curmsgs)
687 if (info->attr.mq_curmsgs < info->attr.mq_maxmsg)
689 spin_unlock(&info->lock);
694 /* Adds current to info->e_wait_q[sr] before element with smaller prio */
695 static void wq_add(struct mqueue_inode_info *info, int sr,
700 list_for_each_entry(walk, &info->e_wait_q[sr].list, list) {
706 list_add_tail(&ewp->list, &info->e_wait_q[sr].list);
714 static int wq_sleep(struct mqueue_inode_info *info, int sr,
716 __releases(&info->lock)
721 wq_add(info, sr, ewp);
724 /* memory barrier not required, we hold info->lock */
727 spin_unlock(&info->lock);
737 spin_lock(&info->lock);
739 /* we hold info->lock, so no memory barrier required */
755 spin_unlock(&info->lock);
764 struct mqueue_inode_info *info, int sr)
768 ptr = info->e_wait_q[sr].list.prev;
769 if (ptr == &info->e_wait_q[sr].list)
783 static void __do_notify(struct mqueue_inode_info *info)
790 if (info->notify_owner &&
791 info->attr.mq_curmsgs == 1) {
792 switch (info->notify.sigev_notify) {
800 if (!info->notify.sigev_signo)
804 sig_i.si_signo = info->notify.sigev_signo;
807 sig_i.si_value = info->notify.sigev_value;
809 /* map current pid/uid into info->owner's namespaces */
811 ns_of_pid(info->notify_owner));
812 sig_i.si_uid = from_kuid_munged(info->notify_user_ns,
821 task = pid_task(info->notify_owner, PIDTYPE_TGID);
823 info->notify_self_exec_id) {
824 do_send_sig_info(info->notify.sigev_signo,
831 set_cookie(info->notify_cookie, NOTIFY_WOKENUP);
832 netlink_sendskb(info->notify_sock, info->notify_cookie);
836 put_pid(info->notify_owner);
837 put_user_ns(info->notify_user_ns);
838 info->notify_owner = NULL;
839 info->notify_user_ns = NULL;
841 wake_up(&info->wait_q);
854 static void remove_notification(struct mqueue_inode_info *info)
856 if (info->notify_owner != NULL &&
857 info->notify.sigev_notify == SIGEV_THREAD) {
858 set_cookie(info->notify_cookie, NOTIFY_REMOVED);
859 netlink_sendskb(info->notify_sock, info->notify_cookie);
861 put_pid(info->notify_owner);
862 put_user_ns(info->notify_user_ns);
863 info->notify_owner = NULL;
864 info->notify_user_ns = NULL;
1008 * - Queue the receiver task for later wakeup (without the info->lock).
1018 struct mqueue_inode_info *info,
1035 struct mqueue_inode_info *info,
1040 __pipelined_op(wake_q, info, receiver);
1046 struct mqueue_inode_info *info)
1048 struct ext_wait_queue *sender = wq_get_first_waiter(info, SEND);
1052 wake_up_interruptible(&info->wait_q);
1055 if (msg_insert(sender->msg, info))
1058 __pipelined_op(wake_q, info, sender);
1070 struct mqueue_inode_info *info;
1097 info = MQUEUE_I(inode);
1105 if (unlikely(msg_len > info->attr.mq_msgsize)) {
1125 if (!info->node_cache)
1128 spin_lock(&info->lock);
1130 if (!info->node_cache && new_leaf) {
1133 info->node_cache = new_leaf;
1139 if (info->attr.mq_curmsgs == info->attr.mq_maxmsg) {
1146 /* memory barrier not required, we hold info->lock */
1148 ret = wq_sleep(info, SEND, timeout, &wait);
1150 * wq_sleep must be called with info->lock held, and
1156 receiver = wq_get_first_waiter(info, RECV);
1158 pipelined_send(&wake_q, info, msg_ptr, receiver);
1161 ret = msg_insert(msg_ptr, info);
1164 __do_notify(info);
1169 spin_unlock(&info->lock);
1188 struct mqueue_inode_info *info;
1211 info = MQUEUE_I(inode);
1220 if (unlikely(msg_len < info->attr.mq_msgsize)) {
1230 if (!info->node_cache)
1233 spin_lock(&info->lock);
1235 if (!info->node_cache && new_leaf) {
1238 info->node_cache = new_leaf;
1243 if (info->attr.mq_curmsgs == 0) {
1245 spin_unlock(&info->lock);
1250 /* memory barrier not required, we hold info->lock */
1252 ret = wq_sleep(info, RECV, timeout, &wait);
1258 msg_ptr = msg_get(info);
1263 pipelined_receive(&wake_q, info);
1264 spin_unlock(&info->lock);
1322 struct mqueue_inode_info *info;
1391 info = MQUEUE_I(inode);
1394 spin_lock(&info->lock);
1396 if (info->notify_owner == task_tgid(current)) {
1397 remove_notification(info);
1400 } else if (info->notify_owner != NULL) {
1405 info->notify.sigev_notify = SIGEV_NONE;
1408 info->notify_sock = sock;
1409 info->notify_cookie = nc;
1412 info->notify.sigev_notify = SIGEV_THREAD;
1415 info->notify.sigev_signo = notification->sigev_signo;
1416 info->notify.sigev_value = notification->sigev_value;
1417 info->notify.sigev_notify = SIGEV_SIGNAL;
1418 info->notify_self_exec_id = current->self_exec_id;
1422 info->notify_owner = get_pid(task_tgid(current));
1423 info->notify_user_ns = get_user_ns(current_user_ns());
1426 spin_unlock(&info->lock);
1455 struct mqueue_inode_info *info;
1470 info = MQUEUE_I(inode);
1472 spin_lock(&info->lock);
1475 *old = info->attr;
1490 spin_unlock(&info->lock);