LinuxGuruz
  • Last 5 Forum Topics
    Replies
    Views
    Last post


The Web Only This Site
  • BOOKMARK

  • ADD TO FAVORITES

  • REFERENCES


  • MARC

    Mailing list ARChives
    - Search by -
     Subjects
     Authors
     Bodies





    FOLDOC

    Computing Dictionary




  • Text Link Ads






  • LINUX man pages
  • Linux Man Page Viewer


    The following form allows you to view linux man pages.

    Command:

    mq_overview

    
    
    

    DESCRIPTION

           POSIX  message  queues  allow processes to exchange data in the form of
           messages.  This API is distinct from that provided by System V  message
           queues  (msgget(2),  msgsnd(2),  msgrcv(2), etc.), but provides similar
           functionality.
    
           Message queues are created and opened using mq_open(3);  this  function
           returns  a  message queue descriptor (mqd_t), which is used to refer to
           the open message queue in later calls.  Each message queue  is  identi-
           fied by a name of the form /somename; that is, a null-terminated string
           of up to NAME_MAX (i.e.,  255)  characters  consisting  of  an  initial
           slash,  followed  by one or more characters, none of which are slashes.
           Two processes can operate on the same queue by passing the same name to
           mq_open(3).
    
           Messages  are  transferred  to  and  from  a queue using mq_send(3) and
           mq_receive(3).  When a process has finished using the queue, it  closes
           it  using mq_close(3), and when the queue is no longer required, it can
           be deleted using mq_unlink(3).  Queue attributes can be  retrieved  and
           (in some cases) modified using mq_getattr(3) and mq_setattr(3).  A pro-
           cess can request asynchronous notification of the arrival of a  message
           on a previously empty queue using mq_notify(3).
    
           A  message  queue  descriptor  is  a reference to an open message queue
           description (cf.  open(2)).  After a fork(2), a child  inherits  copies
           of  its parent's message queue descriptors, and these descriptors refer
           to the same  open  message  queue  descriptions  as  the  corresponding
           descriptors  in  the parent.  Corresponding descriptors in the two pro-
           cesses share the flags (mq_flags) that are  associated  with  the  open
           message queue description.
    
           Each message has an associated priority, and messages are always deliv-
           ered to the receiving process highest priority first.  Message  priori-
           ties  range  from  0  (low) to sysconf(_SC_MQ_PRIO_MAX) - 1 (high).  On
           Linux,  sysconf(_SC_MQ_PRIO_MAX)  returns   32768,   but   POSIX.1-2001
           requires only that an implementation support at least priorities in the
           range 0 to 31; some implementations provide only this range.
    
           The remainder of this section describes some specific  details  of  the
           Linux implementation of POSIX message queues.
    
       Library interfaces and system calls
           In  most  cases  the  mq_*() library interfaces listed above are imple-
           mented on top of underlying system calls of the same name.   Deviations
           from this scheme are indicated in the following table:
    
                  Library interface    System call
                  mq_close(3)          close(2)
                  mq_getattr(3)        mq_getsetattr(2)
                  mq_notify(3)         mq_notify(2)
                  mq_open(3)           mq_open(2)
                  mq_receive(3)        mq_timedreceive(2)
    
       Persistence
           POSIX message  queues  have  kernel  persistence:  if  not  removed  by
           mq_unlink(3), a message queue will exist until the system is shut down.
    
       Linking
           Programs using the POSIX message queue API must  be  compiled  with  cc
           -lrt to link against the real-time library, librt.
    
       /proc interfaces
           The following interfaces can be used to limit the amount of kernel mem-
           ory consumed by POSIX message queues:
    
           /proc/sys/fs/mqueue/msg_max
                  This file can be used to view and change the ceiling  value  for
                  the maximum number of messages in a queue.  This value acts as a
                  ceiling on the attr->mq_maxmsg  argument  given  to  mq_open(3).
                  The default value for msg_max is 10.  The minimum value is 1 (10
                  in  kernels  before  2.6.28).   The  upper  limit  is  HARD_MAX:
                  (131072 / sizeof(void *))  (32768  on  Linux/86).  This limit is
                  ignored for privileged  processes  (CAP_SYS_RESOURCE),  but  the
                  HARD_MAX ceiling is nevertheless imposed.
    
           /proc/sys/fs/mqueue/msgsize_max
                  This file can be used to view and change the ceiling on the max-
                  imum message  size.   This  value  acts  as  a  ceiling  on  the
                  attr->mq_msgsize  argument  given  to  mq_open(3).   The default
                  value for msgsize_max is 8192 bytes.  The minimum value  is  128
                  (8192  in  kernels  before  2.6.28).   The  upper limit for msg-
                  size_max is 1,048,576 (in kernels before 2.6.28, the upper limit
                  was INT_MAX; that is, 2,147,483,647 on Linux/86).  This limit is
                  ignored for privileged processes (CAP_SYS_RESOURCE).
    
           /proc/sys/fs/mqueue/queues_max
                  This file can be used to view and change the  system-wide  limit
                  on the number of message queues that can be created.  Only priv-
                  ileged  processes  (CAP_SYS_RESOURCE)  can  create  new  message
                  queues  once this limit has been reached.  The default value for
                  queues_max is 256; it can be changed to any value in the range 0
                  to INT_MAX.
    
       Resource limit
           The  RLIMIT_MSGQUEUE resource limit, which places a limit on the amount
           of space that can be consumed by all of the message queues belonging to
           a process's real user ID, is described in getrlimit(2).
    
       Mounting the message queue filesystem
           On  Linux,  message queues are created in a virtual filesystem.  (Other
           implementations may also provide such a feature, but  the  details  are
           likely  to  differ.)  This filesystem can be mounted (by the superuser)
           using the following commands:
    
    
           These fields are as follows:
    
           QSIZE  Number of bytes of data in all messages in the queue.
    
           NOTIFY_PID
                  If  this  is  nonzero,  then  the process with this PID has used
                  mq_notify(3) to register for asynchronous message  notification,
                  and the remaining fields describe how notification occurs.
    
           NOTIFY Notification  method:  0 is SIGEV_SIGNAL; 1 is SIGEV_NONE; and 2
                  is SIGEV_THREAD.
    
           SIGNO  Signal number to be used for SIGEV_SIGNAL.
    
       Polling message queue descriptors
           On Linux, a message queue descriptor is actually a file descriptor, and
           can  be  monitored  using select(2), poll(2), or epoll(7).  This is not
           portable.
    
    
    

    CONFORMING TO

           POSIX.1-2001.
    
    
    

    NOTES

           System V message queues (msgget(2), msgsnd(2), msgrcv(2), etc.) are  an
           older  API  for  exchanging  messages between processes.  POSIX message
           queues provide a  better  designed  interface  than  System  V  message
           queues;  on  the other hand POSIX message queues are less widely avail-
           able (especially on older systems) than System V message queues.
    
           Linux does not currently (2.6.26) support the  use  of  access  control
           lists (ACLs) for POSIX message queues.
    
    
    

    EXAMPLE

           An  example  of  the use of various message queue functions is shown in
           mq_notify(3).
    
    
    

    SEE ALSO

           getrlimit(2),  mq_getsetattr(2),   poll(2),   select(2),   mq_close(3),
           mq_getattr(3),  mq_notify(3),  mq_open(3),  mq_receive(3),  mq_send(3),
           mq_unlink(3), epoll(7)
    
    
    

    Linux 2009-09-27 MQ_OVERVIEW(7)

    
    
  • MORE RESOURCE


  • Linux

    The Distributions





    Linux

    The Software





    Linux

    The News



  • MARKETING






  • Toll Free

webmaster@linuxguruz.com
Copyright © 1999 - 2016 by LinuxGuruz