src/WINNT/afsclass/c_agg.cpp

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 #include <winsock2.h>
  11 #include <ws2tcpip.h>
  12
  13 extern "C" {
  14 #include <afsconfig.h>
  15 #include <afs/param.h>
  16 #include <roken.h>
  17 }
  18
  19 #include <WINNT/afsclass.h>
  20 #include "internal.h"
  21
  22
  23 /*
  24  * DEFINITIONS ________________________________________________________________
  25  *
  26  */
  27
  28
  29 /*
  30  * VARIABLES __________________________________________________________________
  31  *
  32  */
  33
  34
  35 /*
  36  * PROTOTYPES _________________________________________________________________
  37  *
  38  */
  39
  40
  41 /*
  42  * ROUTINES ___________________________________________________________________
  43  *
  44  */
  45
  46
  47 AGGREGATE::AGGREGATE (LPSERVER lpServerParent, LPTSTR pszName, LPTSTR pszDevice)
  48 {
  49    m_lpiServer = lpServerParent->GetIdentifier();
  50    m_lpiCell = lpServerParent->m_lpiCell;
  51    m_lpiThis = NULL;
  52
  53    lstrcpy (m_szName, pszName);
  54    lstrcpy (m_szDevice, pszDevice);
  55    m_wGhost = 0;
  56    m_idPartition = NO_PARTITION;
  57
  58    m_fFilesetsOutOfDate = TRUE;
  59    m_lFilesets = New (HASHLIST);
  60    m_lFilesets->SetCriticalSection (AfsClass_GetCriticalSection());
  61    m_lkFilesetName = m_lFilesets->CreateKey ("Fileset Name", AGGREGATE::KeyFilesetName_Compare, AGGREGATE::KeyFilesetName_HashObject, AGGREGATE::KeyFilesetName_HashData);
  62    m_lkFilesetID = m_lFilesets->CreateKey ("Fileset ID", AGGREGATE::KeyFilesetID_Compare, AGGREGATE::KeyFilesetID_HashObject, AGGREGATE::KeyFilesetID_HashData);
  63
  64    m_fStatusOutOfDate = TRUE;
  65    m_fAllocationOutOfDate = TRUE;
  66    memset (&m_as, 0x00, sizeof(AGGREGATESTATUS));
  67 }
  68
  69
  70 AGGREGATE::~AGGREGATE (void)
  71 {
  72    for (LPENUM pEnum = m_lFilesets->FindLast(); pEnum; pEnum = pEnum->FindPrevious())
  73       {
  74       LPFILESET lpFileset = (LPFILESET)(pEnum->GetObject());
  75       m_lFilesets->Remove (lpFileset);
  76       Delete (lpFileset);
  77       }
  78    Delete (m_lFilesets);
  79
  80    if (m_lpiThis)
  81       m_lpiThis->m_cRef --;
  82 }
  83
  84
  85 void AGGREGATE::SendDeleteNotifications (void)
  86 {
  87    for (LPENUM pEnum = m_lFilesets->FindFirst(); pEnum; pEnum = pEnum->FindNext())
  88       {
  89       LPFILESET lpFileset = (LPFILESET)(pEnum->GetObject());
  90       lpFileset->SendDeleteNotifications();
  91       }
  92
  93    NOTIFYCALLBACK::SendNotificationToAll (evtDestroy, GetIdentifier());
  94 }
  95
  96
  97 void AGGREGATE::Close (void)
  98 {
  99    AfsClass_Leave();
 100 }
 101
 102
 103 LPIDENT AGGREGATE::GetIdentifier (void)
 104 {
 105    if (m_lpiThis == NULL)
 106       {
 107       if ((m_lpiThis = IDENT::FindIdent (this)) == NULL)
 108          m_lpiThis = New2 (IDENT,(this));
 109       m_lpiThis->m_cRef ++;
 110       }
 111
 112    return m_lpiThis;
 113 }
 114
 115
 116 void AGGREGATE::Invalidate (void)
 117 {
 118    if (!m_fStatusOutOfDate || !m_fFilesetsOutOfDate)
 119       {
 120       if (m_wGhost & GHOST_HAS_SERVER_ENTRY)
 121          {
 122          m_fStatusOutOfDate = TRUE;
 123          m_fFilesetsOutOfDate = TRUE;
 124          }
 125
 126       NOTIFYCALLBACK::SendNotificationToAll (evtInvalidate, GetIdentifier());
 127       }
 128 }
 129
 130
 131 void AGGREGATE::InvalidateAllocation (void)
 132 {
 133    m_fAllocationOutOfDate = TRUE;
 134 }
 135
 136
 137 BOOL AGGREGATE::RefreshFilesets (BOOL fNotify, ULONG *pStatus)
 138 {
 139    BOOL rc = TRUE;
 140    DWORD status = 0;
 141
 142    if (m_fFilesetsOutOfDate)
 143       {
 144       m_fFilesetsOutOfDate = FALSE;
 145
 146       // We'll need m_as.dwID to do this.
 147       //
 148       if (!RefreshStatus (fNotify, pStatus))
 149          return FALSE;
 150
 151       if (fNotify)
 152          NOTIFYCALLBACK::SendNotificationToAll (evtRefreshFilesetsBegin, GetIdentifier());
 153
 154       // First thing is to forget about what filesets we think we have now.
 155       //
 156       for (LPENUM pEnum = m_lFilesets->FindLast(); pEnum; pEnum = pEnum->FindPrevious())
 157          {
 158          LPFILESET lpFileset = (LPFILESET)(pEnum->GetObject());
 159          lpFileset->SendDeleteNotifications();
 160          m_lFilesets->Remove (lpFileset);
 161          Delete (lpFileset);
 162          }
 163
 164       // Next, the harder part: look through the server to find a list
 165       // of filesets.
 166       //
 167       LPSERVER lpServer;
 168       if ((lpServer = OpenServer (&status)) == NULL)
 169          rc = FALSE;
 170       else
 171          {
 172          PVOID hCell;
 173          PVOID hVOS;
 174          if ((hVOS = lpServer->OpenVosObject (&hCell, &status)) == NULL)
 175             rc = FALSE;
 176          else
 177             {
 178             WORKERPACKET wpBegin;
 179             wpBegin.wpVosVolumeGetBegin.hCell = hCell;
 180             wpBegin.wpVosVolumeGetBegin.hServer = hVOS;
 181             wpBegin.wpVosVolumeGetBegin.idPartition = m_idPartition;
 182
 183             if (!Worker_DoTask (wtaskVosVolumeGetBegin, &wpBegin, &status))
 184                rc = FALSE;
 185             else
 186                {
 187                for (;;)
 188                   {
 189                   WORKERPACKET wpNext;
 190                   wpNext.wpVosVolumeGetNext.hEnum = wpBegin.wpVosVolumeGetBegin.hEnum;
 191                   if (!Worker_DoTask (wtaskVosVolumeGetNext, &wpNext, &status))
 192                      {
 193                      if (status == ADMITERATORDONE)
 194                         status = 0;
 195                      else
 196                         rc = FALSE;
 197                      break;
 198                      }
 199
 200                   LPTSTR pszName = AnsiToString (wpNext.wpVosVolumeGetNext.Data.name);
 201                   LPFILESET lpFileset = New2 (FILESET,(this, &wpNext.wpVosVolumeGetNext.Data.id, pszName));
 202                   FreeString (pszName, wpNext.wpVosVolumeGetNext.Data.name);
 203
 204                   lpFileset->SetStatusFromVOS (&wpNext.wpVosVolumeGetNext.Data);
 205                   lpFileset->m_wGhost |= GHOST_HAS_SERVER_ENTRY;
 206                   m_lFilesets->Add (lpFileset);
 207                   NOTIFYCALLBACK::SendNotificationToAll (evtCreate, lpFileset->GetIdentifier());
 208                   }
 209
 210                WORKERPACKET wpDone;
 211                wpDone.wpVosVolumeGetDone.hEnum = wpBegin.wpVosVolumeGetBegin.hEnum;
 212                Worker_DoTask (wtaskVosVolumeGetDone, &wpDone);
 213                }
 214
 215             lpServer->CloseVosObject();
 216             }
 217
 218          lpServer->Close();
 219          }
 220
 221       InvalidateAllocation();
 222
 223       if (fNotify)
 224          NOTIFYCALLBACK::SendNotificationToAll (evtRefreshFilesetsEnd, GetIdentifier(), ((rc) ? 0 : status));
 225       }
 226
 227    if (pStatus && !rc)
 228       *pStatus = status;
 229    return TRUE;
 230 }
 231
 232
 233 BOOL AGGREGATE::RefreshStatus (BOOL fNotify, ULONG *pStatus)
 234 {
 235    BOOL rc = TRUE;
 236    DWORD status = 0;
 237
 238    if (m_fStatusOutOfDate)
 239       {
 240       m_fStatusOutOfDate = FALSE;
 241
 242       if (fNotify)
 243          NOTIFYCALLBACK::SendNotificationToAll (evtRefreshStatusBegin, GetIdentifier());
 244
 245       LPSERVER lpServer;
 246       if ((lpServer = OpenServer (&status)) == NULL)
 247          rc = FALSE;
 248       else
 249          {
 250          PVOID hCell;
 251          PVOID hVOS;
 252          if ((hVOS = lpServer->OpenVosObject (&hCell, &status)) == NULL)
 253             rc = FALSE;
 254          else
 255             {
 256             WORKERPACKET wp;
 257             wp.wpVosPartitionGet.hCell = hCell;
 258             wp.wpVosPartitionGet.hServer = hVOS;
 259             wp.wpVosPartitionGet.idPartition = m_idPartition;
 260
 261             if (!Worker_DoTask (wtaskVosPartitionGet, &wp, &status))
 262                rc = FALSE;
 263             else
 264                {
 265                m_as.ckStorageTotal = wp.wpVosPartitionGet.Data.totalSpace;
 266                m_as.ckStorageFree = wp.wpVosPartitionGet.Data.totalFreeSpace;
 267                }
 268
 269             m_as.dwID = GetID();
 270             lpServer->CloseVosObject();
 271             }
 272
 273          lpServer->Close();
 274          }
 275
 276       if (fNotify)
 277          NOTIFYCALLBACK::SendNotificationToAll (evtRefreshStatusEnd, GetIdentifier(), ((rc) ? 0 : status));
 278       }
 279
 280    if (rc && m_fAllocationOutOfDate)
 281       {
 282       if (fNotify)
 283          NOTIFYCALLBACK::SendNotificationToAll (evtRefreshStatusBegin, GetIdentifier());
 284
 285       m_as.ckStorageAllocated = CalculateAllocation (fNotify);
 286       m_fAllocationOutOfDate = FALSE;
 287
 288       if (fNotify)
 289          NOTIFYCALLBACK::SendNotificationToAll (evtRefreshStatusEnd, GetIdentifier());
 290       }
 291
 292    if (pStatus && !rc)
 293       *pStatus = status;
 294    return TRUE;
 295 }
 296
 297
 298 size_t AGGREGATE::CalculateAllocation (BOOL fNotify)
 299 {
 300    size_t ckAllocated = 0;
 301
 302    for (LPENUM pEnum = m_lFilesets->FindFirst(); pEnum; pEnum = pEnum->FindNext())
 303       {
 304       LPFILESET lpFileset = (LPFILESET)(pEnum->GetObject());
 305
 306       FILESETSTATUS fs;
 307       if (lpFileset->GetStatus (&fs))
 308          {
 309          if (fs.Type == ftREADWRITE)
 310             ckAllocated += fs.ckQuota;
 311          }
 312       }
 313
 314    return ckAllocated;
 315 }
 316
 317
 318 void AGGREGATE::GetName (LPTSTR pszName)
 319 {
 320    lstrcpy (pszName, m_szName);
 321 }
 322
 323
 324 void AGGREGATE::GetDevice (LPTSTR pszDevice)
 325 {
 326    lstrcpy (pszDevice, m_szDevice);
 327 }
 328
 329
 330 LPCELL AGGREGATE::OpenCell (ULONG *pStatus)
 331 {
 332    return m_lpiCell->OpenCell (pStatus);
 333 }
 334
 335
 336 LPSERVER AGGREGATE::OpenServer (ULONG *pStatus)
 337 {
 338    return m_lpiServer->OpenServer (pStatus);
 339 }
 340
 341
 342 /*
 343  * FILESETS ___________________________________________________________________
 344  *
 345  */
 346
 347 LPFILESET AGGREGATE::OpenFileset (LPTSTR pszName, ULONG *pStatus)
 348 {
 349    if (!RefreshFilesets (TRUE, pStatus))
 350       return NULL;
 351
 352    LPFILESET lpFileset;
 353    if ((lpFileset = (LPFILESET)(m_lkFilesetName->GetFirstObject (pszName))) != NULL)
 354       AfsClass_Enter();
 355
 356    return lpFileset;
 357 }
 358
 359
 360 LPFILESET AGGREGATE::OpenFileset (VOLUMEID *pvidFileset, ULONG *pStatus)
 361 {
 362    if (!RefreshFilesets (TRUE, pStatus))
 363       return NULL;
 364
 365    LPFILESET lpFileset;
 366    if ((lpFileset = (LPFILESET)(m_lkFilesetID->GetFirstObject (pvidFileset))) != NULL)
 367       AfsClass_Enter();
 368
 369    return lpFileset;
 370 }
 371
 372
 373 LPFILESET AGGREGATE::FilesetFindFirst (HENUM *phEnum, BOOL fNotify, ULONG *pStatus)
 374 {
 375    return FilesetFindFirst (phEnum, NULL, fNotify, pStatus);
 376 }
 377
 378
 379 LPFILESET AGGREGATE::FilesetFindFirst (HENUM *phEnum, LPIDENT lpiFind, BOOL fNotify, ULONG *pStatus)
 380 {
 381    LPFILESET lpFileset = NULL;
 382
 383    if (!RefreshFilesets (fNotify, pStatus))
 384       return NULL;
 385
 386    if (lpiFind != NULL)
 387       {
 388       lpFileset = lpiFind->OpenFileset();
 389       *phEnum = NULL;
 390       }
 391    else if ((*phEnum = m_lFilesets->FindFirst()) != NULL)
 392       {
 393       lpFileset = (LPFILESET)( (*phEnum)->GetObject() );
 394       AfsClass_Enter();
 395       }
 396
 397    if (!lpFileset && pStatus)
 398       *pStatus = ERROR_FILE_NOT_FOUND;
 399    return lpFileset;
 400 }
 401
 402
 403 LPFILESET AGGREGATE::FilesetFindNext (HENUM *phEnum)
 404 {
 405    LPFILESET lpFileset = NULL;
 406
 407    if (*phEnum)
 408       {
 409       if ((*phEnum = (*phEnum)->FindNext()) != NULL)
 410          {
 411          lpFileset = (LPFILESET)( (*phEnum)->GetObject() );
 412          AfsClass_Enter();
 413          }
 414       }
 415
 416    return lpFileset;
 417 }
 418
 419
 420 void AGGREGATE::FilesetFindClose (HENUM *phEnum)
 421 {
 422    if (*phEnum)
 423       {
 424       Delete (*phEnum);
 425       *phEnum = NULL;
 426       }
 427 }
 428
 429
 430 BOOL AGGREGATE::GetStatus (LPAGGREGATESTATUS lpas, BOOL fNotify, ULONG *pStatus)
 431 {
 432    if (!RefreshStatus (fNotify, pStatus))
 433       return FALSE;
 434
 435    memcpy (lpas, &m_as, sizeof(AGGREGATESTATUS));
 436    return TRUE;
 437 }
 438
 439
 440 short AGGREGATE::GetGhostStatus (void)
 441 {
 442    return m_wGhost;
 443 }
 444
 445
 446 PVOID AGGREGATE::GetUserParam (void)
 447 {
 448    return GetIdentifier()->GetUserParam();
 449 }
 450
 451
 452 void AGGREGATE::SetUserParam (PVOID pUserNew)
 453 {
 454    GetIdentifier()->SetUserParam (pUserNew);
 455 }
 456
 457
 458 int AGGREGATE::GetID (void)
 459 {
 460    if (m_idPartition == NO_PARTITION)
 461       {
 462       WORKERPACKET wp;
 463       wp.wpVosPartitionNameToId.pszPartition = m_szName;
 464
 465       ULONG status;
 466       if (Worker_DoTask (wtaskVosPartitionNameToId, &wp, &status))
 467          m_idPartition = wp.wpVosPartitionNameToId.idPartition;
 468       }
 469
 470    return m_idPartition;
 471 }
 472
 473
 474 /*
 475  * HASH KEYS __________________________________________________________________
 476  *
 477  */
 478
 479 BOOL CALLBACK AGGREGATE::KeyFilesetName_Compare (LPHASHLISTKEY pKey, PVOID pObject, PVOID pData)
 480 {
 481    return !lstrcmp (((LPFILESET)pObject)->m_szName, (LPTSTR)pData);
 482 }
 483
 484 HASHVALUE CALLBACK AGGREGATE::KeyFilesetName_HashObject (LPHASHLISTKEY pKey, PVOID pObject)
 485 {
 486    return AGGREGATE::KeyFilesetName_HashData (pKey, ((LPFILESET)pObject)->m_szName);
 487 }
 488
 489 HASHVALUE CALLBACK AGGREGATE::KeyFilesetName_HashData (LPHASHLISTKEY pKey, PVOID pData)
 490 {
 491    return HashString ((LPTSTR)pData);
 492 }
 493
 494
 495 BOOL CALLBACK AGGREGATE::KeyFilesetID_Compare (LPHASHLISTKEY pKey, PVOID pObject, PVOID pData)
 496 {
 497    return !memcmp (&((LPFILESET)pObject)->m_idVolume, (LPVOLUMEID)pData, sizeof(VOLUMEID));
 498 }
 499
 500 HASHVALUE CALLBACK AGGREGATE::KeyFilesetID_HashObject (LPHASHLISTKEY pKey, PVOID pObject)
 501 {
 502    return AGGREGATE::KeyFilesetID_HashData (pKey, &((LPFILESET)pObject)->m_idVolume);
 503 }
 504
 505 HASHVALUE CALLBACK AGGREGATE::KeyFilesetID_HashData (LPHASHLISTKEY pKey, PVOID pData)
 506 {
 507    return (HASHVALUE)*((LPVOLUMEID)pData);
 508 }
 509