zypp/sat/detail/PoolImpl.cc

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/sat/detail/PoolImpl.cc
  10  *
  11 */
  12 #include <iostream>
  13 #include <fstream>
  14 #include <boost/mpl/int.hpp>
  15
  16 #include "zypp/base/Easy.h"
  17 #include "zypp/base/LogTools.h"
  18 #include "zypp/base/Gettext.h"
  19 #include "zypp/base/Exception.h"
  20 #include "zypp/base/Measure.h"
  21 #include "zypp/base/WatchFile.h"
  22 #include "zypp/base/Sysconfig.h"
  23 #include "zypp/base/IOStream.h"
  24
  25 #include "zypp/ZConfig.h"
  26
  27 #include "zypp/sat/detail/PoolImpl.h"
  28 #include "zypp/sat/SolvableSet.h"
  29 #include "zypp/sat/Pool.h"
  30 #include "zypp/Capability.h"
  31 #include "zypp/Locale.h"
  32 #include "zypp/PoolItem.h"
  33
  34 #include "zypp/target/modalias/Modalias.h"
  35 #include "zypp/media/MediaPriority.h"
  36
  37 extern "C"
  38 {
  39 // Workaround libsolv project not providing a common include
  40 // directory. (the -devel package does, but the git repo doesn't).
  41 // #include <solv/repo_helix.h>
  42 int repo_add_helix( ::Repo *repo, FILE *fp, int flags );
  43 }
  44
  45 using std::endl;
  46
  47 #undef  ZYPP_BASE_LOGGER_LOGGROUP
  48 #define ZYPP_BASE_LOGGER_LOGGROUP "zypp::satpool"
  49
  50 // ///////////////////////////////////////////////////////////////////
  51 namespace zypp
  52 {
  53   /////////////////////////////////////////////////////////////////
  54   namespace env
  55   {
  56     /**  */
  57     inline int LIBSOLV_DEBUGMASK()
  58     {
  59       const char * envp = getenv("LIBSOLV_DEBUGMASK");
  60       return envp ? str::strtonum<int>( envp ) : 0;
  61     }
  62   } // namespace env
  63   ///////////////////////////////////////////////////////////////////
  64   namespace sat
  65   { /////////////////////////////////////////////////////////////////
  66
  67     ///////////////////////////////////////////////////////////////////
  68     namespace detail
  69     { /////////////////////////////////////////////////////////////////
  70
  71       // MPL checks for satlib constants we redefine to avoid
  72       // includes and defines.
  73       BOOST_MPL_ASSERT_RELATION( noId,                 ==, STRID_NULL );
  74       BOOST_MPL_ASSERT_RELATION( emptyId,              ==, STRID_EMPTY );
  75
  76       BOOST_MPL_ASSERT_RELATION( noSolvableId,         ==, ID_NULL );
  77       BOOST_MPL_ASSERT_RELATION( systemSolvableId,     ==, SYSTEMSOLVABLE );
  78
  79       BOOST_MPL_ASSERT_RELATION( solvablePrereqMarker, ==, SOLVABLE_PREREQMARKER );
  80       BOOST_MPL_ASSERT_RELATION( solvableFileMarker,   ==, SOLVABLE_FILEMARKER );
  81
  82       BOOST_MPL_ASSERT_RELATION( CapDetail::CAP_AND,       ==, REL_AND );
  83       BOOST_MPL_ASSERT_RELATION( CapDetail::CAP_OR,        ==, REL_OR );
  84       BOOST_MPL_ASSERT_RELATION( CapDetail::CAP_WITH,      ==, REL_WITH );
  85       BOOST_MPL_ASSERT_RELATION( CapDetail::CAP_NAMESPACE, ==, REL_NAMESPACE );
  86       BOOST_MPL_ASSERT_RELATION( CapDetail::CAP_ARCH,      ==, REL_ARCH );
  87
  88       BOOST_MPL_ASSERT_RELATION( namespaceModalias,     ==, NAMESPACE_MODALIAS );
  89       BOOST_MPL_ASSERT_RELATION( namespaceLanguage,     ==, NAMESPACE_LANGUAGE );
  90       BOOST_MPL_ASSERT_RELATION( namespaceFilesystem,   ==, NAMESPACE_FILESYSTEM );
  91
  92       /////////////////////////////////////////////////////////////////
  93
  94       const std::string & PoolImpl::systemRepoAlias()
  95       {
  96         static const std::string _val( "@System" );
  97         return _val;
  98       }
  99
 100       const Pathname & sysconfigStoragePath()
 101       {
 102         static const Pathname _val( "/etc/sysconfig/storage" );
 103         return _val;
 104       }
 105
 106       /////////////////////////////////////////////////////////////////
 107
 108       static void logSat( CPool *, void *data, int type, const char *logString )
 109       {
 110         //                            "1234567890123456789012345678901234567890
 111         if ( 0 == strncmp( logString, "  - no rule created", 19 ) )
 112           return;
 113         if ( 0 == strncmp( logString, "    next rules: 0 0", 19 ) )
 114           return;
 115
 116         if ( type & (SOLV_FATAL|SOLV_ERROR) ) {
 117           L_ERR("libsolv") << logString;
 118         } else if ( type & SOLV_DEBUG_STATS ) {
 119           L_DBG("libsolv") << logString;
 120         } else {
 121           L_MIL("libsolv") << logString;
 122         }
 123       }
 124
 125       detail::IdType PoolImpl::nsCallback( CPool *, void * data, detail::IdType lhs, detail::IdType rhs )
 126       {
 127         // lhs:    the namespace identifier, e.g. NAMESPACE:MODALIAS
 128         // rhs:    the value, e.g. pci:v0000104Cd0000840[01]sv*sd*bc*sc*i*
 129         // return: 0 if not supportded
 130         //         1 if supported by the system
 131         //        -1  AFAIK it's also possible to return a list of solvables that support it, but don't know how.
 132
 133         static const detail::IdType RET_unsupported    = 0;
 134         static const detail::IdType RET_systemProperty = 1;
 135         switch ( lhs )
 136         {
 137           case NAMESPACE_LANGUAGE:
 138           {
 139             const TrackedLocaleIds & localeIds( reinterpret_cast<PoolImpl*>(data)->trackedLocaleIds() );
 140             return localeIds.contains( IdString(rhs) ) ? RET_systemProperty : RET_unsupported;
 141           }
 142           break;
 143
 144           case NAMESPACE_MODALIAS:
 145           {
 146             // modalias strings in capability may be hexencoded because rpm does not allow
 147             // ',', ' ' or other special chars.
 148             return target::Modalias::instance().query( str::hexdecode( IdString(rhs).c_str() ) )
 149                 ? RET_systemProperty
 150               : RET_unsupported;
 151           }
 152           break;
 153
 154           case NAMESPACE_FILESYSTEM:
 155           {
 156             const std::set<std::string> & requiredFilesystems( reinterpret_cast<PoolImpl*>(data)->requiredFilesystems() );
 157             return requiredFilesystems.find( IdString(rhs).asString() ) != requiredFilesystems.end() ? RET_systemProperty : RET_unsupported;
 158           }
 159           break;
 160
 161         }
 162
 163         WAR << "Unhandled " << Capability( lhs ) << " vs. " << Capability( rhs ) << endl;
 164         return RET_unsupported;
 165       }
 166
 167       ///////////////////////////////////////////////////////////////////
 168       //
 169       //        METHOD NAME : PoolMember::myPool
 170       //        METHOD TYPE : PoolImpl
 171       //
 172       PoolImpl & PoolMember::myPool()
 173       {
 174         static PoolImpl _global;
 175         return _global;
 176       }
 177
 178       ///////////////////////////////////////////////////////////////////
 179       //
 180       //        METHOD NAME : PoolImpl::PoolImpl
 181       //        METHOD TYPE : Ctor
 182       //
 183       PoolImpl::PoolImpl()
 184       : _pool( ::pool_create() )
 185       {
 186         MIL << "Creating sat-pool." << endl;
 187         if ( ! _pool )
 188         {
 189           ZYPP_THROW( Exception( _("Can not create sat-pool.") ) );
 190         }
 191         // by now we support only a RPM backend
 192         ::pool_setdisttype(_pool, DISTTYPE_RPM );
 193
 194         // initialialize logging
 195         if ( env::LIBSOLV_DEBUGMASK() )
 196         {
 197           ::pool_setdebugmask(_pool, env::LIBSOLV_DEBUGMASK() );
 198         }
 199         else
 200         {
 201           if ( getenv("ZYPP_LIBSOLV_FULLLOG") || getenv("ZYPP_LIBSAT_FULLLOG") )
 202             ::pool_setdebuglevel( _pool, 3 );
 203           else if ( getenv("ZYPP_FULLLOG") )
 204             ::pool_setdebuglevel( _pool, 2 );
 205           else
 206             ::pool_setdebugmask(_pool, SOLV_DEBUG_JOB|SOLV_DEBUG_STATS );
 207         }
 208
 209         ::pool_setdebugcallback( _pool, logSat, NULL );
 210
 211         // set namespace callback
 212         _pool->nscallback = &nsCallback;
 213         _pool->nscallbackdata = (void*)this;
 214       }
 215
 216       ///////////////////////////////////////////////////////////////////
 217       //
 218       //        METHOD NAME : PoolImpl::~PoolImpl
 219       //        METHOD TYPE : Dtor
 220       //
 221       PoolImpl::~PoolImpl()
 222       {
 223         ::pool_free( _pool );
 224       }
 225
 226      ///////////////////////////////////////////////////////////////////
 227
 228       void PoolImpl::setDirty( const char * a1, const char * a2, const char * a3 )
 229       {
 230         if ( a1 )
 231         {
 232           if      ( a3 ) MIL << a1 << " " << a2 << " " << a3 << endl;
 233           else if ( a2 ) MIL << a1 << " " << a2 << endl;
 234           else           MIL << a1 << endl;
 235         }
 236         _serial.setDirty();           // pool content change
 237         _availableLocalesPtr.reset(); // available locales may change
 238         _multiversionListPtr.reset(); // re-evaluate ZConfig::multiversionSpec.
 239
 240         depSetDirty();  // invaldate dependency/namespace related indices
 241       }
 242
 243       void PoolImpl::localeSetDirty( const char * a1, const char * a2, const char * a3 )
 244       {
 245         if ( a1 )
 246         {
 247           if      ( a3 ) MIL << a1 << " " << a2 << " " << a3 << endl;
 248           else if ( a2 ) MIL << a1 << " " << a2 << endl;
 249           else           MIL << a1 << endl;
 250         }
 251         _trackedLocaleIdsPtr.reset();   // requested locales changed
 252         depSetDirty();  // invaldate dependency/namespace related indices
 253       }
 254
 255       void PoolImpl::depSetDirty( const char * a1, const char * a2, const char * a3 )
 256       {
 257         if ( a1 )
 258         {
 259           if      ( a3 ) MIL << a1 << " " << a2 << " " << a3 << endl;
 260           else if ( a2 ) MIL << a1 << " " << a2 << endl;
 261           else           MIL << a1 << endl;
 262         }
 263         ::pool_freewhatprovides( _pool );
 264       }
 265
 266       void PoolImpl::prepare() const
 267       {
 268         // additional /etc/sysconfig/storage check:
 269         static WatchFile sysconfigFile( sysconfigStoragePath(), WatchFile::NO_INIT );
 270         if ( sysconfigFile.hasChanged() )
 271         {
 272           _requiredFilesystemsPtr.reset(); // recreated on demand
 273           const_cast<PoolImpl*>(this)->depSetDirty( "/etc/sysconfig/storage change" );
 274         }
 275         if ( _watcher.remember( _serial ) )
 276         {
 277           // After repo/solvable add/remove:
 278           // set pool architecture
 279           ::pool_setarch( _pool,  ZConfig::instance().systemArchitecture().asString().c_str() );
 280         }
 281         if ( ! _pool->whatprovides )
 282         {
 283           MIL << "pool_createwhatprovides..." << endl;
 284
 285           ::pool_addfileprovides( _pool );
 286           ::pool_createwhatprovides( _pool );
 287         }
 288         if ( ! _pool->languages )
 289         {
 290           // initial seting
 291           const_cast<PoolImpl*>(this)->setTextLocale( ZConfig::instance().textLocale() );
 292         }
 293       }
 294
 295       ///////////////////////////////////////////////////////////////////
 296
 297       CRepo * PoolImpl::_createRepo( const std::string & name_r )
 298       {
 299         setDirty(__FUNCTION__, name_r.c_str() );
 300         CRepo * ret = ::repo_create( _pool, name_r.c_str() );
 301         if ( ret && name_r == systemRepoAlias() )
 302           ::pool_set_installed( _pool, ret );
 303         return ret;
 304       }
 305
 306       void PoolImpl::_deleteRepo( CRepo * repo_r )
 307       {
 308         setDirty(__FUNCTION__, repo_r->name );
 309         if ( isSystemRepo( repo_r ) )
 310           _autoinstalled.clear();
 311         eraseRepoInfo( repo_r );
 312         ::repo_free( repo_r, /*resusePoolIDs*/false );
 313         // If the last repo is removed clear the pool to actually reuse all IDs.
 314         // NOTE: the explicit ::repo_free above asserts all solvables are memset(0)!
 315         if ( !_pool->urepos )
 316           ::pool_freeallrepos( _pool, /*resusePoolIDs*/true );
 317       }
 318
 319       int PoolImpl::_addSolv( CRepo * repo_r, FILE * file_r )
 320       {
 321         setDirty(__FUNCTION__, repo_r->name );
 322         int ret = ::repo_add_solv( repo_r, file_r, 0 );
 323         if ( ret == 0 )
 324           _postRepoAdd( repo_r );
 325         return ret;
 326       }
 327
 328       int PoolImpl::_addHelix( CRepo * repo_r, FILE * file_r )
 329       {
 330         setDirty(__FUNCTION__, repo_r->name );
 331         int ret = ::repo_add_helix( repo_r, file_r, 0 );
 332         if ( ret == 0 )
 333           _postRepoAdd( repo_r );
 334         return 0;
 335       }
 336
 337       void PoolImpl::_postRepoAdd( CRepo * repo_r )
 338       {
 339         if ( ! isSystemRepo( repo_r ) )
 340         {
 341             // Filter out unwanted archs
 342           std::set<detail::IdType> sysids;
 343           {
 344             Arch::CompatSet sysarchs( Arch::compatSet( ZConfig::instance().systemArchitecture() ) );
 345             for_( it, sysarchs.begin(), sysarchs.end() )
 346               sysids.insert( it->id() );
 347
 348               // unfortunately libsolv treats src/nosrc as architecture:
 349             sysids.insert( ARCH_SRC );
 350             sysids.insert( ARCH_NOSRC );
 351           }
 352
 353           detail::IdType blockBegin = 0;
 354           unsigned       blockSize  = 0;
 355           for ( detail::IdType i = repo_r->start; i < repo_r->end; ++i )
 356           {
 357               CSolvable * s( _pool->solvables + i );
 358               if ( s->repo == repo_r && sysids.find( s->arch ) == sysids.end() )
 359               {
 360                 // Remember an unwanted arch entry:
 361                 if ( ! blockBegin )
 362                   blockBegin = i;
 363                 ++blockSize;
 364               }
 365               else if ( blockSize )
 366               {
 367                 // Free remembered entries
 368                   ::repo_free_solvable_block( repo_r, blockBegin, blockSize, /*resusePoolIDs*/false );
 369                   blockBegin = blockSize = 0;
 370               }
 371           }
 372           if ( blockSize )
 373           {
 374               // Free remembered entries
 375               ::repo_free_solvable_block( repo_r, blockBegin, blockSize, /*resusePoolIDs*/false );
 376               blockBegin = blockSize = 0;
 377           }
 378         }
 379       }
 380
 381       detail::SolvableIdType PoolImpl::_addSolvables( CRepo * repo_r, unsigned count_r )
 382       {
 383         setDirty(__FUNCTION__, repo_r->name );
 384         return ::repo_add_solvable_block( repo_r, count_r );
 385       }
 386
 387       void PoolImpl::setRepoInfo( RepoIdType id_r, const RepoInfo & info_r )
 388       {
 389         CRepo * repo( getRepo( id_r ) );
 390         if ( repo )
 391         {
 392           bool dirty = false;
 393
 394           // libsolv priority is based on '<', while yum's repoinfo
 395           // uses 1(highest)->99(lowest). Thus we use -info_r.priority.
 396           if ( repo->priority != int(-info_r.priority()) )
 397           {
 398             repo->priority = -info_r.priority();
 399             dirty = true;
 400           }
 401
 402           // subpriority is used to e.g. prefer http over dvd iff
 403           // both have same priority.
 404           int mediaPriority( media::MediaPriority( info_r.url() ) );
 405           if ( repo->subpriority != mediaPriority )
 406           {
 407             repo->subpriority = mediaPriority;
 408             dirty = true;
 409           }
 410
 411           if ( dirty )
 412             setDirty(__FUNCTION__, info_r.alias().c_str() );
 413         }
 414         _repoinfos[id_r] = info_r;
 415       }
 416
 417       ///////////////////////////////////////////////////////////////////
 418
 419       void PoolImpl::setTextLocale( const Locale & locale_r )
 420       {
 421         std::vector<std::string> fallbacklist;
 422         for ( Locale l( locale_r ); l; l = l.fallback() )
 423         {
 424           fallbacklist.push_back( l.code() );
 425         }
 426         dumpRangeLine( MIL << "pool_set_languages: ", fallbacklist.begin(), fallbacklist.end() ) << endl;
 427
 428         std::vector<const char *> fallbacklist_cstr;
 429         for_( it, fallbacklist.begin(), fallbacklist.end() )
 430         {
 431           fallbacklist_cstr.push_back( it->c_str() );
 432         }
 433         ::pool_set_languages( _pool, &fallbacklist_cstr.front(), fallbacklist_cstr.size() );
 434       }
 435
 436       void PoolImpl::initRequestedLocales( const LocaleSet & locales_r )
 437       {
 438         if ( _requestedLocalesTracker.setInitial( locales_r ) )
 439         {
 440           localeSetDirty( "initRequestedLocales" );
 441           MIL << "Init RequestedLocales: " << _requestedLocalesTracker << " =" << locales_r << endl;
 442         }
 443       }
 444
 445       void PoolImpl::setRequestedLocales( const LocaleSet & locales_r )
 446       {
 447         if ( _requestedLocalesTracker.set( locales_r ) )
 448         {
 449           localeSetDirty( "setRequestedLocales" );
 450           MIL << "New RequestedLocales: " << _requestedLocalesTracker << " =" << locales_r << endl;
 451         }
 452       }
 453
 454       bool PoolImpl::addRequestedLocale( const Locale & locale_r )
 455       {
 456         bool done = _requestedLocalesTracker.add( locale_r );
 457         if ( done )
 458         {
 459           localeSetDirty( "addRequestedLocale", locale_r.code().c_str() );
 460           MIL << "New RequestedLocales: " << _requestedLocalesTracker << " +" << locale_r << endl;
 461         }
 462         return done;
 463       }
 464
 465       bool PoolImpl::eraseRequestedLocale( const Locale & locale_r )
 466       {
 467         bool done = _requestedLocalesTracker.remove( locale_r );
 468         if ( done )
 469         {
 470           localeSetDirty( "addRequestedLocale", locale_r.code().c_str() );
 471           MIL << "New RequestedLocales: " << _requestedLocalesTracker << " -" << locale_r << endl;
 472         }
 473         return done;
 474       }
 475
 476
 477       const PoolImpl::TrackedLocaleIds & PoolImpl::trackedLocaleIds() const
 478       {
 479         if ( ! _trackedLocaleIdsPtr )
 480         {
 481           _trackedLocaleIdsPtr.reset( new TrackedLocaleIds );
 482
 483           const base::SetTracker<LocaleSet> &   localesTracker( _requestedLocalesTracker );
 484           TrackedLocaleIds &                    localeIds( *_trackedLocaleIdsPtr );
 485
 486           // Add current locales+fallback except for added ones
 487           for ( Locale lang: localesTracker.current() )
 488           {
 489             if ( localesTracker.wasAdded( lang ) )
 490               continue;
 491             for ( ; lang; lang = lang.fallback() )
 492             { localeIds.current().insert( IdString(lang) ); }
 493           }
 494
 495           // Add added locales+fallback except they are already in current
 496           for ( Locale lang: localesTracker.added() )
 497           {
 498             for ( ; lang && localeIds.current().insert( IdString(lang) ).second; lang = lang.fallback() )
 499             { localeIds.added().insert( IdString(lang) ); }
 500           }
 501
 502           // Add removed locales+fallback except they are still in current
 503           for ( Locale lang: localesTracker.removed() )
 504           {
 505             for ( ; lang && ! localeIds.current().count( IdString(lang) ); lang = lang.fallback() )
 506             { localeIds.removed().insert( IdString(lang) ); }
 507           }
 508
 509           // Assert that TrackedLocaleIds::current is not empty.
 510           // If, so fill in LanguageCode::enCode as last resort.
 511           if ( localeIds.current().empty() )
 512           { localeIds.current().insert( IdString(Locale::enCode) ); }
 513         }
 514         return *_trackedLocaleIdsPtr;
 515       }
 516
 517
 518       static void _getLocaleDeps( const Capability & cap_r, LocaleSet & store_r )
 519       {
 520         // Collect locales from any 'namespace:language(lang)' dependency
 521         CapDetail detail( cap_r );
 522         if ( detail.kind() == CapDetail::EXPRESSION )
 523         {
 524           switch ( detail.capRel() )
 525           {
 526             case CapDetail::CAP_AND:
 527             case CapDetail::CAP_OR:
 528               // expand
 529               _getLocaleDeps( detail.lhs(), store_r );
 530               _getLocaleDeps( detail.rhs(), store_r );
 531               break;
 532
 533             case CapDetail::CAP_NAMESPACE:
 534               if ( detail.lhs().id() == NAMESPACE_LANGUAGE )
 535               {
 536                 store_r.insert( Locale( IdString(detail.rhs().id()) ) );
 537               }
 538               break;
 539
 540             case CapDetail::REL_NONE:
 541             case CapDetail::CAP_WITH:
 542             case CapDetail::CAP_ARCH:
 543               break; // unwanted
 544           }
 545         }
 546       }
 547
 548       const LocaleSet & PoolImpl::getAvailableLocales() const
 549       {
 550         if ( !_availableLocalesPtr )
 551         {
 552           _availableLocalesPtr.reset( new LocaleSet );
 553           LocaleSet & localeSet( *_availableLocalesPtr );
 554
 555           for ( const Solvable & pi : Pool::instance().solvables() )
 556           {
 557             for ( const Capability & cap : pi.supplements() )
 558             {
 559               _getLocaleDeps( cap, localeSet );
 560             }
 561           }
 562         }
 563         return *_availableLocalesPtr;
 564       }
 565
 566       ///////////////////////////////////////////////////////////////////
 567
 568       void PoolImpl::multiversionListInit() const
 569       {
 570         _multiversionListPtr.reset( new MultiversionList );
 571         MultiversionList & multiversionList( *_multiversionListPtr );
 572
 573         MultiversionList::size_type size = 0;
 574         for ( const std::string & spec : ZConfig::instance().multiversionSpec() )
 575         {
 576           static const std::string prefix( "provides:" );
 577           bool provides = str::hasPrefix( spec, prefix );
 578
 579           for ( Solvable solv : WhatProvides( Capability( provides ? spec.c_str() + prefix.size() : spec.c_str() ) ) )
 580           {
 581             if ( provides || solv.ident() == spec )
 582               multiversionList.insert( solv );
 583           }
 584
 585           MultiversionList::size_type nsize = multiversionList.size();
 586           MIL << "Multiversion install " << spec << ": " << (nsize-size) << " matches" << endl;
 587           size = nsize;
 588         }
 589       }
 590
 591       void PoolImpl::multiversionSpecChanged()
 592       { _multiversionListPtr.reset(); }
 593
 594       const PoolImpl::MultiversionList & PoolImpl::multiversionList() const
 595       {
 596         if ( ! _multiversionListPtr )
 597           multiversionListInit();
 598         return *_multiversionListPtr;
 599       }
 600
 601       bool PoolImpl::isMultiversion( const Solvable & solv_r ) const
 602       { return multiversionList().contains( solv_r ); }
 603
 604       ///////////////////////////////////////////////////////////////////
 605
 606       const std::set<std::string> & PoolImpl::requiredFilesystems() const
 607       {
 608         if ( ! _requiredFilesystemsPtr )
 609         {
 610           _requiredFilesystemsPtr.reset( new std::set<std::string> );
 611           std::set<std::string> & requiredFilesystems( *_requiredFilesystemsPtr );
 612           str::split( base::sysconfig::read( sysconfigStoragePath() )["USED_FS_LIST"],
 613                       std::inserter( requiredFilesystems, requiredFilesystems.end() ) );
 614         }
 615         return *_requiredFilesystemsPtr;
 616       }
 617
 618       /////////////////////////////////////////////////////////////////
 619     } // namespace detail
 620     ///////////////////////////////////////////////////////////////////
 621     /////////////////////////////////////////////////////////////////
 622   } // namespace sat
 623   ///////////////////////////////////////////////////////////////////
 624   /////////////////////////////////////////////////////////////////
 625 } // namespace zypp
 626 ///////////////////////////////////////////////////////////////////