rom/filesys/ram/notification.c

   1 /*
   2
   3 File: notification.c
   4 Author: Neil Cafferkey
   5 Copyright (C) 2001-2008 Neil Cafferkey
   6
   7 This file is free software; you can redistribute it and/or modify it
   8 under the terms of the GNU Lesser General Public License as
   9 published by the Free Software Foundation; either version 2.1 of the
  10 License, or (at your option) any later version.
  11
  12 This file is distributed in the hope that it will be useful, but
  13 WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15 Lesser General Public License for more details.
  16
  17 You should have received a copy of the GNU Lesser General Public
  18 License along with this file; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  20 MA 02111-1307, USA.
  21
  22 */
  23
  24
  25 #include "handler_protos.h"
  26
  27
  28 static VOID NotifyObject(struct Handler *handler, struct Object *object);
  29
  30
  31
  32 /****i* ram.handler/MatchNotifyRequests ************************************
  33 *
  34 *   NAME
  35 *       MatchNotifyRequests --
  36 *
  37 *   SYNOPSIS
  38 *       MatchNotifyRequests(handler)
  39 *
  40 *       VOID MatchNotifyRequests(struct Handler *);
  41 *
  42 *   FUNCTION
  43 *
  44 *   INPUTS
  45 *
  46 *   RESULT
  47 *
  48 *   EXAMPLE
  49 *
  50 *   NOTES
  51 *
  52 *   BUGS
  53 *
  54 *   SEE ALSO
  55 *
  56 ****************************************************************************
  57 *
  58 */
  59
  60 VOID MatchNotifyRequests(struct Handler *handler)
  61 {
  62    struct Notification *notification, *next_notification, *tail;
  63    struct Object *object;
  64
  65    next_notification = (APTR)handler->notifications.mlh_Head;
  66    tail = (APTR)&handler->notifications.mlh_Tail;
  67
  68    while(next_notification != tail)
  69    {
  70       notification = next_notification;
  71       next_notification = (APTR)((struct MinNode *)notification)->mln_Succ;
  72
  73       object = GetHardObject(handler, NULL,
  74          notification->request->nr_FullName, NULL);
  75       if(object != NULL)
  76       {
  77          Remove((APTR)notification);
  78          AddTail((APTR)&object->notifications, (APTR)notification);
  79       }
  80    }
  81
  82    return;
  83 }
  84
  85
  86
  87 /****i* ram.handler/UnmatchNotifyRequests **********************************
  88 *
  89 *   NAME
  90 *       UnmatchNotifyRequests --
  91 *
  92 *   SYNOPSIS
  93 *       UnmatchNotifyRequests(handler, object)
  94 *
  95 *       VOID UnmatchNotifyRequests(struct Handler *, struct Object *);
  96 *
  97 *   FUNCTION
  98 *
  99 *   INPUTS
 100 *
 101 *   RESULT
 102 *
 103 *   EXAMPLE
 104 *
 105 *   NOTES
 106 *
 107 *   BUGS
 108 *
 109 *   SEE ALSO
 110 *
 111 ****************************************************************************
 112 *
 113 */
 114
 115 VOID UnmatchNotifyRequests(struct Handler *handler, struct Object *object)
 116 {
 117    struct Notification *notification, *next_notification, *tail;
 118
 119    next_notification = (APTR)object->notifications.mlh_Head;
 120    tail = (APTR)&object->notifications.mlh_Tail;
 121
 122    while(next_notification != tail)
 123    {
 124       notification = next_notification;
 125       next_notification = (APTR)((struct MinNode *)notification)->mln_Succ;
 126
 127       Remove((APTR)notification);
 128       AddTail((APTR)&handler->notifications, (APTR)notification);
 129    }
 130
 131    return;
 132 }
 133
 134
 135
 136 /****i* ram.handler/NotifyAll **********************************************
 137 *
 138 *   NAME
 139 *       NotifyAll --
 140 *
 141 *   SYNOPSIS
 142 *       NotifyAll(handler, object, notify_links)
 143 *
 144 *       VOID NotifyAll(struct Handler *, struct Object *, BOOL);
 145 *
 146 *   FUNCTION
 147 *
 148 *   INPUTS
 149 *
 150 *   RESULT
 151 *
 152 *   EXAMPLE
 153 *
 154 *   NOTES
 155 *
 156 *   BUGS
 157 *
 158 *   SEE ALSO
 159 *
 160 ****************************************************************************
 161 *
 162 */
 163
 164 VOID NotifyAll(struct Handler *handler, struct Object *object,
 165    BOOL notify_links)
 166 {
 167    struct MinNode *tail, *link_node;
 168
 169    if(notify_links)
 170    {
 171       object = GetRealObject(object);
 172       link_node = object->hard_link.mln_Succ;
 173       if(link_node != NULL)
 174       {
 175          tail = (APTR)&HARDLINK(link_node)->elements.mlh_Tail;
 176       }
 177       else
 178          notify_links = FALSE;
 179    }
 180
 181    if(notify_links)
 182    {
 183       link_node = &object->hard_link;
 184
 185       while(link_node != tail)
 186       {
 187          object = HARDLINK(link_node);
 188          NotifyObject(handler, object);
 189          NotifyObject(handler, object->parent);
 190          link_node = link_node->mln_Succ;
 191       }
 192    }
 193    else
 194    {
 195       NotifyObject(handler, object);
 196       NotifyObject(handler, object->parent);
 197    }
 198
 199    return;
 200 }
 201
 202
 203
 204 /****i* ram.handler/NotifyObject *******************************************
 205 *
 206 *   NAME
 207 *       NotifyObject --
 208 *
 209 *   SYNOPSIS
 210 *       NotifyObject(handler, object)
 211 *
 212 *       VOID NotifyObject(struct Handler *, struct Object *);
 213 *
 214 *   FUNCTION
 215 *
 216 *   INPUTS
 217 *
 218 *   RESULT
 219 *
 220 *   EXAMPLE
 221 *
 222 *   NOTES
 223 *
 224 *   BUGS
 225 *
 226 *   SEE ALSO
 227 *
 228 ****************************************************************************
 229 *
 230 */
 231
 232 static VOID NotifyObject(struct Handler *handler, struct Object *object)
 233 {
 234    struct Notification *notification, *tail;
 235
 236    if(object != NULL)
 237    {
 238       notification = (APTR)object->notifications.mlh_Head;
 239       tail = (APTR)&object->notifications.mlh_Tail;
 240
 241       while(notification != tail)
 242       {
 243          Notify(handler, notification);
 244          notification = (APTR)((struct MinNode *)notification)->mln_Succ;
 245       }
 246    }
 247
 248    return;
 249 }
 250
 251
 252
 253 /****i* ram.handler/FindNotification ***************************************
 254 *
 255 *   NAME
 256 *       FindNotification --
 257 *
 258 *   SYNOPSIS
 259 *       notification = FindNotification(handler,
 260 *           request)
 261 *
 262 *       struct Notification *FindNotification(struct Handler *,
 263 *           struct NotifyRequest);
 264 *
 265 *   FUNCTION
 266 *
 267 *   INPUTS
 268 *
 269 *   RESULT
 270 *
 271 *   EXAMPLE
 272 *
 273 *   NOTES
 274 *
 275 *   BUGS
 276 *
 277 *   SEE ALSO
 278 *
 279 ****************************************************************************
 280 *
 281 */
 282
 283 struct Notification *FindNotification(struct Handler *handler,
 284    struct NotifyRequest *request)
 285 {
 286    struct Notification *notification, *tail;
 287    struct MinList *list;
 288    BOOL found;
 289    struct Object *object;
 290
 291    /* Find which list the request should be in */
 292
 293    object = GetHardObject(handler, NULL, request->nr_FullName, NULL);
 294    if(object != NULL)
 295       list = &object->notifications;
 296    else
 297       list = &handler->notifications;
 298
 299    /* Search the list */
 300
 301    notification = (APTR)list->mlh_Head;
 302    tail = (APTR)&list->mlh_Tail;
 303    found = FALSE;
 304
 305    while(notification != tail && !found)
 306    {
 307       if(notification->request == request)
 308          found = TRUE;
 309       else
 310          notification = (APTR)((struct MinNode *)notification)->mln_Succ;
 311    }
 312
 313    if(!found)
 314       notification = NULL;
 315
 316    return notification;
 317 }
 318
 319
 320
 321 /****i* ram.handler/ReceiveNotifyReply *************************************
 322 *
 323 *   NAME
 324 *       ReceiveNotifyReply --
 325 *
 326 *   SYNOPSIS
 327 *       ReceiveNotifyReply(handler, message)
 328 *
 329 *       VOID ReceiveNotifyReply(struct Handler *, struct NotifyMessage *);
 330 *
 331 *   FUNCTION
 332 *
 333 *   INPUTS
 334 *
 335 *   RESULT
 336 *
 337 *   EXAMPLE
 338 *
 339 *   NOTES
 340 *
 341 *   BUGS
 342 *
 343 *   SEE ALSO
 344 *
 345 ****************************************************************************
 346 *
 347 */
 348
 349 VOID ReceiveNotifyReply(struct Handler *handler,
 350    struct NotifyMessage *message)
 351 {
 352    struct NotifyRequest *request;
 353    struct Notification *notification = NULL;
 354
 355    /* Get request and free message */
 356
 357    request = message->nm_NReq;
 358    FreePooled(handler->public_pool, message, sizeof(struct NotifyMessage));
 359
 360    /* Get notification if EndNotify() hasn't been called */
 361
 362    if(request->nr_FullName != NULL)
 363       notification = FindNotification(handler, request);
 364    if(notification != NULL)
 365    {
 366       request->nr_MsgCount--;
 367
 368       /* Send a new notification if there's one pending */
 369
 370       if((request->nr_Flags & NRF_MAGIC) != 0)
 371       {
 372          request->nr_Flags &= ~NRF_MAGIC;
 373          Notify(handler, notification);
 374       }
 375    }
 376
 377    return;
 378 }
 379
 380
 381
 382 /****i* ram.handler/Notify *************************************************
 383 *
 384 *   NAME
 385 *       Notify --
 386 *
 387 *   SYNOPSIS
 388 *       Notify(handler, notification)
 389 *
 390 *       VOID Notify(struct Handler *, struct Notification *);
 391 *
 392 *   FUNCTION
 393 *
 394 *   INPUTS
 395 *
 396 *   RESULT
 397 *
 398 *   EXAMPLE
 399 *
 400 *   NOTES
 401 *
 402 *   BUGS
 403 *
 404 *   SEE ALSO
 405 *
 406 ****************************************************************************
 407 *
 408 */
 409
 410 VOID Notify(struct Handler *handler, struct Notification *notification)
 411 {
 412    struct NotifyMessage *message;
 413    struct NotifyRequest *request;
 414    ULONG flags;
 415
 416    request = notification->request;
 417    flags = request->nr_Flags;
 418    if((flags & NRF_SEND_MESSAGE) != 0)
 419    {
 420       /* Send message now or remember to send it later */
 421
 422       if((flags & NRF_WAIT_REPLY) == 0 || request->nr_MsgCount == 0)
 423       {
 424          message = AllocPooled(handler->public_pool,
 425             sizeof(struct NotifyMessage));
 426          if(message != NULL)
 427          {
 428             ((struct Message *)message)->mn_ReplyPort =
 429                handler->notify_port;
 430             ((struct Message *)message)->mn_Length =
 431                sizeof(struct NotifyMessage);
 432             message->nm_NReq = request;
 433             message->nm_Class = NOTIFY_CLASS;
 434             message->nm_Code = NOTIFY_CODE;
 435
 436             PutMsg(request->nr_stuff.nr_Msg.nr_Port, (APTR)message);
 437             request->nr_MsgCount++;
 438          }
 439       }
 440       else
 441          request->nr_Flags |= NRF_MAGIC;
 442    }
 443    else
 444    {
 445       Signal(request->nr_stuff.nr_Signal.nr_Task,
 446          1 << (request->nr_stuff.nr_Signal.nr_SignalNum));
 447    }
 448
 449    return;
 450 }
 451
 452
 453