rom/filesys/pfs3/fs/dd_support.c

   1 /* $Id$ */
   2 /* $Log: dd_support.c $
   3  * Revision 1.9  1999/02/22  16:33:43  Michiel
   4  * Changes for increasing deldir capacity
   5  *
   6  * Revision 1.8  1998/09/27  11:26:37  Michiel
   7  * ErrorMsg param
   8  *
   9  * Revision 1.7  1997/03/03  22:04:04  Michiel
  10  * Release 16.21
  11  *
  12  * Revision 1.6  1996/03/29  17:02:54  Michiel
  13  * update sleeproutines
  14  *
  15  * Revision 1.5  1996/01/30  12:49:23  Michiel
  16  * --- working tree overlap ---
  17  * new notify routines
  18  * */
  19
  20 /**********************
  21  * function prototypes
  22  */
  23
  24 static BOOL RenameDisk(UBYTE *, globaldata *);
  25
  26 static void NotifyUser(struct NotifyRequest *nr, globaldata *g);
  27 static struct notifyobject *CheckNotify(ULONG parentanodenr, DSTR objectname,
  28         struct notifyobject *no, BOOL checkparent, globaldata *);
  29 void PFSDoNotify(struct fileinfo *object, BOOL checkparent, globaldata *g);
  30 void PFSUpdateNotify(ULONG dirnode, DSTR filename, ULONG anodenr, globaldata *g);
  31
  32 /* AFS extensions */
  33 #if EXTRAPACKETS
  34 static void Sleep (globaldata *g);
  35 static void Awake (globaldata *g);
  36 static void Alarm (globaldata *g);
  37 static LONG UpdateAnode (ULONG old, ULONG new, globaldata *g);
  38 void HandleSleepMsg (globaldata *g);
  39 #endif
  40
  41 /**********************
  42  * macros
  43  */
  44
  45 #define SkipColon(filename,pathname)                                \
  46 do {                                                                   \
  47         if ((filename = strchr ((pathname), ':')))                       \
  48                 filename++;                                                 \
  49         else                                                            \
  50                 filename=(pathname);                                        \
  51 } while (0)
  52
  53 #define LocateFile(parentfi,filename,objectfi,error)                \
  54 do {                                                                   \
  55         if (!FindObject (parentfi, filename, &(objectfi), error, g))    \
  56                 return DOSFALSE;                                            \
  57                                                                                                                                         \
  58         if (IsVolume(objectfi))                                         \
  59         {                                                               \
  60                 *error = ERROR_OBJECT_WRONG_TYPE;                           \
  61                 return DOSFALSE;                                            \
  62         }                                                               \
  63 } while (0)
  64
  65 #if MULTIUSER
  66 #define muGetRelationship(extrafields)                              \
  67         ((g->muFS_ready) ?                                              \
  68         (muGetRelationshipA (g->user, ((extrafields).uid << 16) + (extrafields).gid, NULL)) :   \
  69         ((((extrafields).uid == muNOBODY_UID) << muRelB_NO_OWNER) | muRelF_NOBODY))
  70
  71 #if DELDIR
  72 #define CheckPropertyAccess(objectfi,extrafields,flags, error)      \
  73 do {                                                                   \
  74         GetExtraFieldsOI (&(objectfi), &(extrafields), g);                  \
  75         if (g->muFS_ready)                                              \
  76                 flags = muGetRelationshipA (g->user, ((extrafields).uid << 16) + (extrafields).gid, NULL);  \
  77         else                                                                                        \
  78                 flags = (((extrafields).uid == muNOBODY_UID) << muRelB_NO_OWNER) | muRelF_NOBODY;         \
  79                                                                                                                                         \
  80         if (!(flags & muRel_PROPERTY_ACCESS))                           \
  81         {                                                               \
  82                 *error = ERROR_WRITE_PROTECTED;                             \
  83                 return DOSFALSE;                                            \
  84         }                                                               \
  85 } while (0)
  86 #else /* DELDIR */
  87 #define CheckPropertyAccess(objectfi,extrafields,flags, error)      \
  88 do {                                                                   \
  89         GetExtraFields ((objectfi).file.direntry, &(extrafields));          \
  90         if (g->muFS_ready)                                              \
  91                 flags = muGetRelationshipA (g->user, ((extrafields).uid << 16) + (extrafields).gid, NULL);  \
  92         else                                                                                        \
  93                 flags = (((extrafields).uid == muNOBODY_UID) << muRelB_NO_OWNER) | muRelF_NOBODY;         \
  94                                                                                                                                         \
  95         if (!(flags & muRel_PROPERTY_ACCESS))                           \
  96         {                                                               \
  97                 *error = ERROR_WRITE_PROTECTED;                             \
  98                 return DOSFALSE;                                            \
  99         }                                                               \
 100 } while (0)
 101 #endif /* DELDIR */
 102
 103 #else /* MULTIUSER */
 104 #define muGetRelationship(extrafields)
 105 #define CheckPropertyAccess(objectfi,extrafields,flags,error)
 106 #endif /* MULTIUSER */
 107
 108 /*
 109  * BPTR, BOOL, listentry_t *, union objectinfo *
 110  */
 111 #define GetFileInfoFromLock(argument, access, fe, fi)               \
 112 do {                                                                   \
 113         if ((fe = LockEntryFromLock (argument)))                        \
 114         {                                                               \
 115                 if (!CheckVolume ((fe)->le.volume, access, error, g))         \
 116                         return DOSFALSE;                                        \
 117                 UpdateLE ((listentry_t *)(fe), g);                                           \
 118                 fi = &(fe)->le.info;                                             \
 119         }                                                               \
 120         else                                                            \
 121         {                                                               \
 122                 if (!g->currentvolume)                                      \
 123                 {                                                           \
 124                         *error = ERROR_NO_DISK;                                 \
 125                         return DOSFALSE;                                        \
 126                 }                                                           \
 127                 fi = NULL;                                                  \
 128         }                                                               \
 129 } while (0)
 130
 131
 132
 133 /**********************
 134  * rename disk
 135  */
 136
 137 static BOOL RenameDisk (UBYTE *newname, globaldata *g)  //%4.5
 138 {
 139   UBYTE *diskname;
 140   struct volumedata *volume = g->currentvolume;
 141
 142         ENTER("RenameDisk");
 143
 144         if (g->currentvolume && (strlen(newname) < DNSIZE))
 145         {
 146                 /* Write changes directly to disk to prevent disk recognition problems.
 147                  * (So DON'T use updatedisk)
 148                 */
 149                 diskname = volume->rootblk->diskname;
 150                 *diskname = strlen(newname);
 151                 CopyMem (newname, diskname+1, strlen(newname));
 152                 RawWrite ((UBYTE *)volume->rootblk, 1, ROOTBLOCK, g);   /* %7.2 */
 153                 g->request->iotd_Req.io_Command = CMD_UPDATE;
 154                 DoIO ((struct IORequest *)g->request);
 155                 volume->rootblockchangeflag = FALSE;
 156                 return DOSTRUE;
 157         }
 158         else
 159         {
 160                 return DOSFALSE;
 161         }
 162 }
 163
 164
 165 /**********************
 166  * notify stuff
 167  */
 168
 169 static void NotifyUser (struct NotifyRequest *nr, globaldata *g)
 170 {
 171   struct NotifyMessage *msg;
 172
 173         if (nr->nr_MsgCount && (nr->nr_Flags & NRF_WAIT_REPLY))
 174         {
 175                 nr->nr_Flags |= NRF_MAGIC;
 176                 return;
 177         }
 178
 179         if (nr->nr_Flags & NRF_SEND_MESSAGE)
 180         {
 181                 if (!(msg = AllocMemP (sizeof(struct NotifyMessage), g)))
 182                         return;
 183
 184                 msg->nm_ExecMessage.mn_ReplyPort = g->notifyport;
 185                 msg->nm_ExecMessage.mn_Length = sizeof(struct NotifyMessage);
 186                 msg->nm_Class = NOTIFY_CLASS;
 187                 msg->nm_Code = NOTIFY_CODE;
 188                 msg->nm_NReq = nr;
 189                 PutMsg (nr->nr_stuff.nr_Msg.nr_Port, &msg->nm_ExecMessage);
 190                 nr->nr_MsgCount++;
 191         }
 192         else if (nr->nr_Flags & NRF_SEND_SIGNAL)
 193         {
 194                 Signal (nr->nr_stuff.nr_Signal.nr_Task, 1<<nr->nr_stuff.nr_Signal.nr_SignalNum);
 195         }
 196 }
 197
 198 /*
 199  * Checks if there is a notify for the object identified by anodenr
 200  */
 201 static struct notifyobject *
 202 CheckNotify (ULONG parentanodenr, DSTR objectname, struct notifyobject *no,
 203                          BOOL checkparent, globaldata *g)
 204 {
 205         if (!no)
 206                 no = HeadOf(&g->currentvolume->notifylist);
 207         else
 208                 no = no->next;
 209
 210         for ( ; no->next; no=no->next)
 211         {
 212                 /* file match */
 213                 if (no->parentanodenr == parentanodenr)
 214                 {
 215                         if (intlcmp(no->objectname, objectname))
 216                                 return no;
 217                 }
 218
 219                 /* parent match */
 220                 if (checkparent && no->anodenr == parentanodenr)
 221                         return no;
 222         }
 223
 224         return NULL;
 225 }
 226
 227 /*
 228  * Notifies change of object & dir object is in
 229  */
 230 void PFSDoNotify (struct fileinfo *object, BOOL checkparent, globaldata *g)
 231 {
 232         struct notifyobject *no = NULL;
 233
 234 #if DELDIR
 235         if ((IPTR)object->direntry <= SPECIAL_DELFILE)
 236                 return;
 237 #endif
 238
 239         while ((no = CheckNotify (object->dirblock->blk.anodenr,
 240                                 (DSTR)&object->direntry->nlength, no, checkparent, g)))
 241                 NotifyUser(no->req, g);
 242 }
 243
 244
 245 /*
 246  * To be called when a object named filename is created in dir
 247  * dirnode. This routine checks if there is a partially parsed
 248  * notify request in that directory that matches the newly
 249  * created object. If so, the parsing of the notify request
 250  * can continue.
 251  */
 252 void PFSUpdateNotify (ULONG dirnode, DSTR filename, ULONG anodenr, globaldata *g)
 253 {
 254   struct notifyobject *no = NULL;
 255   UBYTE *temp;
 256
 257         for (no = HeadOf(&g->currentvolume->notifylist); no->next; no=no->next)
 258         {
 259                 /* check for parsed path match */
 260                 if (no->parentanodenr == dirnode)
 261                 {
 262                         if (no->unparsed)
 263                         {
 264                                 /* check if we can continue parsing */
 265                                 temp = strchr(no->unparsed, '/');
 266                                 if (temp)
 267                                         *temp = 0;
 268
 269                                 if (intlcdcmp(no->unparsed, filename))
 270                                 {
 271                                         if (temp)
 272                                                 no->unparsed = *(temp+1) ? (temp+1) : NULL;
 273                                         else
 274                                                 no->unparsed = NULL;
 275
 276                                         no->parentanodenr = anodenr;
 277                                 }
 278
 279                                 if (temp)
 280                                         *temp = '/';
 281                         }
 282                         else
 283                         {
 284                                 /* check if new object is a notify object */
 285                                 if (intlcmp(no->objectname, filename))
 286                                 {
 287                                         no->anodenr = anodenr;
 288                                 }
 289                         }
 290                 }
 291         }
 292 }
 293
 294
 295 /**********************
 296  * AFS extension
 297  */
 298
 299 #if EXTRAPACKETS
 300 /*
 301  * Enter MODE_SLEEP
 302  *
 303  * All direct directory block references are replaced by an
 304  * anode reference. The reference can later be restored by
 305  * searching the object in the directory identified by the
 306  * diranodenr.
 307  *
 308  * Examine chains have to be broken since sleepwalkers are
 309  * allowed to change directory order
 310  */
 311 static void Sleep (globaldata *g)
 312 {
 313         listentry_t *le;
 314         struct volumedata *volume = g->currentvolume;
 315
 316         if (volume)
 317         {
 318                 /* first update disk */
 319                 UpdateDisk (g);
 320
 321                 /* flush references */
 322                 for (le=HeadOf (&volume->fileentries); le->next; le=le->next)
 323                 {
 324                         if (!IsVolumeEntry(le))
 325                         {
 326                                 /* load flushed references */
 327                                 if (le->dirblocknr)
 328                                         LoadDirBlock (le->dirblocknr, g);
 329
 330                                 le->diranodenr = le->info.file.dirblock->blk.anodenr;
 331                         }
 332
 333                         if (IsFileEntry(le))
 334                         {
 335                                 fileentry_t *fe = (fileentry_t *)le;
 336
 337                                 if (fe->anodechain)
 338                                         DetachAnodeChain (fe->anodechain, g);
 339
 340                                 fe->currnode = NULL;
 341                         }
 342                 }
 343
 344                 /* now kill all flushed references (they are now replaced
 345                  * by anode references in le->diranodenr)
 346                  */
 347                 for (le=HeadOf (&volume->fileentries); le->next; le=le->next)
 348                 {
 349                         le->dirblocknr = 0;
 350
 351                         /* terminate examine chains */
 352                         if (le->type.flags.dir && !IsDelDir(le->info))
 353                         {
 354                                 ((lockentry_t *)le)->nextentry.direntry = NULL;
 355                                 ((lockentry_t *)le)->nextentry.dirblock = NULL;
 356                                 ((lockentry_t *)le)->nextdirblocknr = 0;
 357                                 ((lockentry_t *)le)->nextdirblockoffset = 0;
 358                         }
 359                 }
 360
 361
 362                 /* flush cache. Watch it: FreeUnusedResources also calls
 363                  * the conventional FlushBlock!
 364                  */
 365                 FreeUnusedResources (volume, g);
 366         }
 367
 368         /* set sleepmode */
 369         g->sleepmode = TRUE;
 370
 371         /* enter sleepmode */
 372         g->DoCommand = SleepCommands;
 373 }
 374
 375 /*
 376  * Leave MODE_SLEEP
 377  *
 378  * Reload all essential blocks. References are restored by searching
 379  * by anodenr in the directory identified by diranodenr (using FetchObject)
 380  */
 381 static void Awake (globaldata *g)
 382 {
 383   listentry_t *le;
 384   struct volumedata *volume = g->currentvolume;
 385   struct rootblock *rootblock;
 386   SIPTR error;
 387
 388         if (volume)
 389         {
 390                 /* reload current rootblock  */
 391                 rootblock = volume->rootblk;
 392                 RawRead((UBYTE *)rootblock, rootblock->rblkcluster, ROOTBLOCK, g);
 393
 394                 /* reload rootblock extension */
 395                 if (rootblock->extension && (rootblock->options & MODE_EXTENSION))
 396                         RawRead((UBYTE *)&volume->rblkextension->blk, volume->rescluster,
 397                                 rootblock->extension, g);
 398
 399                 /* reload deldir */
 400                 // if (rootblock->deldir && (rootblock->options & MODE_DELDIR))
 401                 //      RawRead((UBYTE *)&volume->deldir->blk, volume->rescluster,
 402                 //              rootblock->deldir, g);
 403
 404                 /* reconfigure modules */
 405                 InitModules (volume, FALSE, g);
 406
 407                 /* restore references */
 408                 for (le=HeadOf (&volume->fileentries); le->next; le=le->next)
 409                 {
 410                         if (!IsVolumeEntry(le))
 411                         {
 412                                 if (!FetchObject(le->diranodenr, le->anodenr, &le->info, g))
 413                                         ErrorMsg(AFS_ERROR_UNSLEEP, NULL, g);  /*  -> kill, invalidate lock <- */
 414
 415                                 if (IsFileEntry(le))
 416                                 {
 417                                   ULONG offset;
 418                                   fileentry_t *fe = (fileentry_t *)le;
 419
 420                                         /* restore anodechain and fe->currnode */
 421                                         if (!(fe->anodechain = GetAnodeChain(fe->le.anodenr, g)))
 422                                                 ;   /* kill, invalidate */
 423
 424                                         offset = fe->offset;
 425                                         fe->currnode = &fe->anodechain->head;
 426                                         fe->offset = fe->blockoffset = fe->anodeoffset = 0;
 427                                         if (SeekInObject(fe, offset, OFFSET_BEGINNING, &error, g) == -1)
 428                                                 ErrorMsg(AFS_ERROR_UNSLEEP, NULL, g);  /* -> kill, invalidate */
 429                                 }
 430                         }
 431                 }
 432         }
 433
 434         // --> prevent 'normal' reference-restore on loading
 435         //  directory blocks
 436
 437         /* unset sleepmode */
 438         g->sleepmode = FALSE;
 439
 440         /* awake */
 441         g->DoCommand = NormalCommands;
 442 }
 443
 444 /*
 445  * Disk accessing packets are pending --> wake up!
 446  * Handshaking sleeptask <-> AFS
 447  */
 448 static void Alarm (globaldata *g)
 449 {
 450   ULONG sleepmask = 1<<g->alarmsignal;
 451
 452         /* signal task that we want to wake up */
 453         Signal (g->sleeptask, sleepmask);
 454
 455         while (g->sleepmode)
 456         {
 457                 WaitPort (g->sleepport);
 458                 HandleSleepMsg (g);
 459         }
 460 }
 461
 462
 463
 464 /*
 465  * Reflect changed anode in locklist references
 466  * returns number of references updated
 467  * (MODE_SLEEP only)
 468  */
 469 static LONG UpdateAnode (ULONG old, ULONG new, globaldata *g)
 470 {
 471   listentry_t *le;
 472   struct notifyobject *no;
 473   LONG i=0;
 474   struct volumedata *volume = g->currentvolume;
 475
 476         /*
 477          * Update fileentry list
 478          */
 479
 480         for (le=(listentry_t *)HeadOf(&volume->fileentries); le->next; le=le->next)
 481         {
 482                 if (!IsVolumeEntry(le))
 483                 {
 484                         if (le->anodenr == old)
 485                         {
 486                                 i++;
 487                                 if (!new)
 488                                         ;   /* invalidate le */
 489                                 le->anodenr = new;
 490                         }
 491
 492                         if (le->diranodenr == old)
 493                         {
 494                                 i++;
 495                                 le->diranodenr = new;
 496                         }
 497                 }
 498         }
 499
 500         /*
 501          * Update notify list
 502          */
 503
 504         for (no=HeadOf(&g->currentvolume->notifylist); no->next; no=no->next)
 505         {
 506                 if (no->anodenr == old)
 507                 {
 508                         i++;
 509                         no->anodenr = new;
 510                 }
 511         }
 512
 513         return i;
 514 }
 515
 516 /*
 517  * Message handler for messages on the sleepport
 518  */
 519 void HandleSleepMsg (globaldata *g)
 520 {
 521   struct Message *msg;
 522
 523         while ((msg = GetMsg (g->sleepport)))
 524         {
 525                 if (g->sleepmode)
 526                 {
 527                         g->action = (struct DosPacket *)msg->mn_Node.ln_Name;
 528                         (g->DoCommand)(g->action, g);
 529                 }
 530                 else
 531                 {
 532                         g->action->dp_Res1 = DOSFALSE;
 533                         g->action->dp_Res2 = ERROR_ACTION_NOT_KNOWN;
 534                 }
 535
 536                 ReturnPacket (g->action, g->sleepport, g);
 537         }
 538 }
 539
 540 #endif