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);
193 static int msg_insert(struct msg_msg *msg, struct mqueue_inode_info *info)
199 p = &info->msg_tree.rb_node;
212 if (info->node_cache) {
213 leaf = info->node_cache;
214 info->node_cache = NULL;
224 info->msg_tree_rightmost = &leaf->rb_node;
227 rb_insert_color(&leaf->rb_node, &info->msg_tree);
229 info->attr.mq_curmsgs++;
230 info->qsize += msg->m_ts;
236 struct mqueue_inode_info *info)
240 if (info->msg_tree_rightmost == node)
241 info->msg_tree_rightmost = rb_prev(node);
243 rb_erase(node, &info->msg_tree);
244 if (info->node_cache)
247 info->node_cache = leaf;
250 static inline struct msg_msg *msg_get(struct mqueue_inode_info *info)
262 parent = info->msg_tree_rightmost;
264 if (info->attr.mq_curmsgs) {
268 info->attr.mq_curmsgs = 0;
277 msg_tree_erase(leaf, info);
284 msg_tree_erase(leaf, info);
287 info->attr.mq_curmsgs--;
288 info->qsize -= msg->m_ts;
311 struct mqueue_inode_info *info;
316 /* mqueue specific info */
317 info = MQUEUE_I(inode);
318 spin_lock_init(&info->lock);
319 init_waitqueue_head(&info->wait_q);
320 INIT_LIST_HEAD(&info->e_wait_q[0].list);
321 INIT_LIST_HEAD(&info->e_wait_q[1].list);
322 info->notify_owner = NULL;
323 info->notify_user_ns = NULL;
324 info->qsize = 0;
325 info->user = NULL; /* set when all is ok */
326 info->msg_tree = RB_ROOT;
327 info->msg_tree_rightmost = NULL;
328 info->node_cache = NULL;
329 memset(&info->attr, 0, sizeof(info->attr));
330 info->attr.mq_maxmsg = min(ipc_ns->mq_msg_max,
332 info->attr.mq_msgsize = min(ipc_ns->mq_msgsize_max,
335 info->attr.mq_maxmsg = attr->mq_maxmsg;
336 info->attr.mq_msgsize = attr->mq_msgsize;
353 if (info->attr.mq_maxmsg <= 0 || info->attr.mq_msgsize <= 0)
356 if (info->attr.mq_maxmsg > HARD_MSGMAX ||
357 info->attr.mq_msgsize > HARD_MSGSIZEMAX)
360 if (info->attr.mq_maxmsg > ipc_ns->mq_msg_max ||
361 info->attr.mq_msgsize > ipc_ns->mq_msgsize_max)
366 if (info->attr.mq_msgsize > ULONG_MAX/info->attr.mq_maxmsg)
368 mq_treesize = info->attr.mq_maxmsg * sizeof(struct msg_msg) +
369 min_t(unsigned int, info->attr.mq_maxmsg, MQ_PRIO_MAX) *
371 mq_bytes = info->attr.mq_maxmsg * info->attr.mq_msgsize;
379 /* mqueue_evict_inode() releases info->messages */
387 info->user = get_uid(u);
513 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 user = info->user;
542 mq_treesize = info->attr.mq_maxmsg * sizeof(struct msg_msg) +
543 min_t(unsigned int, info->attr.mq_maxmsg, MQ_PRIO_MAX) *
546 mq_bytes = mq_treesize + (info->attr.mq_maxmsg *
547 info->attr.mq_msgsize);
631 * to read only queue size & notification info (the only values
638 struct mqueue_inode_info *info = MQUEUE_I(file_inode(filp));
642 spin_lock(&info->lock);
645 info->qsize,
646 info->notify_owner ? info->notify.sigev_notify : 0,
647 (info->notify_owner &&
648 info->notify.sigev_notify == SIGEV_SIGNAL) ?
649 info->notify.sigev_signo : 0,
650 pid_vnr(info->notify_owner));
651 spin_unlock(&info->lock);
665 struct mqueue_inode_info *info = MQUEUE_I(file_inode(filp));
667 spin_lock(&info->lock);
668 if (task_tgid(current) == info->notify_owner)
669 remove_notification(info);
671 spin_unlock(&info->lock);
677 struct mqueue_inode_info *info = MQUEUE_I(file_inode(filp));
680 poll_wait(filp, &info->wait_q, poll_tab);
682 spin_lock(&info->lock);
683 if (info->attr.mq_curmsgs)
686 if (info->attr.mq_curmsgs < info->attr.mq_maxmsg)
688 spin_unlock(&info->lock);
693 /* Adds current to info->e_wait_q[sr] before element with smaller prio */
694 static void wq_add(struct mqueue_inode_info *info, int sr,
699 list_for_each_entry(walk, &info->e_wait_q[sr].list, list) {
705 list_add_tail(&ewp->list, &info->e_wait_q[sr].list);
713 static int wq_sleep(struct mqueue_inode_info *info, int sr,
715 __releases(&info->lock)
720 wq_add(info, sr, ewp);
723 /* memory barrier not required, we hold info->lock */
726 spin_unlock(&info->lock);
736 spin_lock(&info->lock);
738 /* we hold info->lock, so no memory barrier required */
754 spin_unlock(&info->lock);
763 struct mqueue_inode_info *info, int sr)
767 ptr = info->e_wait_q[sr].list.prev;
768 if (ptr == &info->e_wait_q[sr].list)
782 static void __do_notify(struct mqueue_inode_info *info)
789 if (info->notify_owner &&
790 info->attr.mq_curmsgs == 1) {
791 switch (info->notify.sigev_notify) {
799 if (!info->notify.sigev_signo)
803 sig_i.si_signo = info->notify.sigev_signo;
806 sig_i.si_value = info->notify.sigev_value;
808 /* map current pid/uid into info->owner's namespaces */
810 ns_of_pid(info->notify_owner));
811 sig_i.si_uid = from_kuid_munged(info->notify_user_ns,
820 task = pid_task(info->notify_owner, PIDTYPE_TGID);
822 info->notify_self_exec_id) {
823 do_send_sig_info(info->notify.sigev_signo,
830 set_cookie(info->notify_cookie, NOTIFY_WOKENUP);
831 netlink_sendskb(info->notify_sock, info->notify_cookie);
835 put_pid(info->notify_owner);
836 put_user_ns(info->notify_user_ns);
837 info->notify_owner = NULL;
838 info->notify_user_ns = NULL;
840 wake_up(&info->wait_q);
853 static void remove_notification(struct mqueue_inode_info *info)
855 if (info->notify_owner != NULL &&
856 info->notify.sigev_notify == SIGEV_THREAD) {
857 set_cookie(info->notify_cookie, NOTIFY_REMOVED);
858 netlink_sendskb(info->notify_sock, info->notify_cookie);
860 put_pid(info->notify_owner);
861 put_user_ns(info->notify_user_ns);
862 info->notify_owner = NULL;
863 info->notify_user_ns = NULL;
1007 * - Queue the receiver task for later wakeup (without the info->lock).
1017 struct mqueue_inode_info *info,
1034 struct mqueue_inode_info *info,
1039 __pipelined_op(wake_q, info, receiver);
1045 struct mqueue_inode_info *info)
1047 struct ext_wait_queue *sender = wq_get_first_waiter(info, SEND);
1051 wake_up_interruptible(&info->wait_q);
1054 if (msg_insert(sender->msg, info))
1057 __pipelined_op(wake_q, info, sender);
1069 struct mqueue_inode_info *info;
1096 info = MQUEUE_I(inode);
1104 if (unlikely(msg_len > info->attr.mq_msgsize)) {
1124 if (!info->node_cache)
1127 spin_lock(&info->lock);
1129 if (!info->node_cache && new_leaf) {
1132 info->node_cache = new_leaf;
1138 if (info->attr.mq_curmsgs == info->attr.mq_maxmsg) {
1145 /* memory barrier not required, we hold info->lock */
1147 ret = wq_sleep(info, SEND, timeout, &wait);
1149 * wq_sleep must be called with info->lock held, and
1155 receiver = wq_get_first_waiter(info, RECV);
1157 pipelined_send(&wake_q, info, msg_ptr, receiver);
1160 ret = msg_insert(msg_ptr, info);
1163 __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);
1264 pipelined_receive(&wake_q, info);
1265 spin_unlock(&info->lock);
1323 struct mqueue_inode_info *info;
1392 info = MQUEUE_I(inode);
1395 spin_lock(&info->lock);
1397 if (info->notify_owner == task_tgid(current)) {
1398 remove_notification(info);
1401 } else if (info->notify_owner != NULL) {
1406 info->notify.sigev_notify = SIGEV_NONE;
1409 info->notify_sock = sock;
1410 info->notify_cookie = nc;
1413 info->notify.sigev_notify = SIGEV_THREAD;
1416 info->notify.sigev_signo = notification->sigev_signo;
1417 info->notify.sigev_value = notification->sigev_value;
1418 info->notify.sigev_notify = SIGEV_SIGNAL;
1419 info->notify_self_exec_id = current->self_exec_id;
1423 info->notify_owner = get_pid(task_tgid(current));
1424 info->notify_user_ns = get_user_ns(current_user_ns());
1427 spin_unlock(&info->lock);
1456 struct mqueue_inode_info *info;
1471 info = MQUEUE_I(inode);
1473 spin_lock(&info->lock);
1476 *old = info->attr;
1491 spin_unlock(&info->lock);