userlibandfileserver/fileserver/sfsrv/cl_plugin.cpp
branchRCL_3
changeset 257 3e88ff8f41d5
parent 256 c1f20ce4abcf
equal deleted inserted replaced
256:c1f20ce4abcf 257:3e88ff8f41d5
    15 // 
    15 // 
    16 //
    16 //
    17 
    17 
    18 #include "cl_std.h"
    18 #include "cl_std.h"
    19 
    19 
    20 #ifdef OST_TRACE_COMPILER_IN_USE
       
    21 #include "cl_pluginTraces.h"
       
    22 #endif
       
    23 
       
    24  
    20  
    25 EXPORT_C TInt RFs::AddPlugin(const TDesC& aFileName) const
    21 EXPORT_C TInt RFs::AddPlugin(const TDesC& aFileName) const
    26 /**
    22 /**
    27 @internalTechnology
    23 @internalTechnology
    28 
    24 
    33 @return KErrNone, if successful; otherwise one of the other system wide error codes.
    29 @return KErrNone, if successful; otherwise one of the other system wide error codes.
    34 
    30 
    35 @capability DiskAdmin
    31 @capability DiskAdmin
    36 */
    32 */
    37 	{
    33 	{
    38 	OstTrace1(TRACE_BORDER, EFSRV_EFSADDPLUGIN, "sess %x", Handle());
    34 	TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsAddPlugin, MODULEUID, Handle(), aFileName);
    39 	OstTraceData(TRACE_BORDER, EFSRV_EFSADDPLUGIN_EFILENAME, "FileName %S", aFileName.Ptr(), aFileName.Length()<<1);
       
    40 
    35 
    41 	RLoader loader;
    36 	RLoader loader;
    42 	TInt r = loader.Connect();
    37 	TInt r = loader.Connect();
    43 	if (r==KErrNone)
    38 	if (r==KErrNone)
    44 		{
    39 		{
    45 		r = loader.SendReceive(ELoadFSPlugin, TIpcArgs(0, &aFileName, 0));
    40 		r = loader.SendReceive(ELoadFSPlugin, TIpcArgs(0, &aFileName, 0));
    46 		loader.Close();
    41 		loader.Close();
    47 		}
    42 		}
    48 
    43 
    49 	OstTrace1(TRACE_BORDER, EFSRV_EFSADDPLUGINRETURN, "r %d", r);
    44 	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsAddPluginReturn, MODULEUID, r);
    50 
       
    51 	return r;
    45 	return r;
    52 	}
    46 	}
    53 
    47 
    54 EXPORT_C TInt RFs::RemovePlugin(const TDesC& aPluginName) const
    48 EXPORT_C TInt RFs::RemovePlugin(const TDesC& aPluginName) const
    55 /**
    49 /**
    64         otrherwise one of the other system-wide error codes.
    58         otrherwise one of the other system-wide error codes.
    65 
    59 
    66 @capability DiskAdmin
    60 @capability DiskAdmin
    67 */
    61 */
    68 	{
    62 	{
    69 	OstTrace1(TRACE_BORDER, EFSRV_EFSREMOVEPLUGIN, "sess %x", Handle());
    63 	TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsRemovePlugin, MODULEUID, Handle(), aPluginName);
    70 	OstTraceData(TRACE_BORDER, EFSRV_EFSREMOVEPLUGIN_EPLUGINNAME, "PluginName %S", aPluginName.Ptr(), aPluginName.Length()<<1);
       
    71 
    64 
    72 	TInt r = SendReceive(EFsRemovePlugin,TIpcArgs(&aPluginName));
    65 	TInt r = SendReceive(EFsRemovePlugin,TIpcArgs(&aPluginName));
    73 
    66 
    74 	OstTrace1(TRACE_BORDER, EFSRV_EFSREMOVEPLUGINRETURN, "r %d", r);
    67 	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsRemovePluginReturn, MODULEUID, r);
    75 
       
    76 	return r;
    68 	return r;
    77 	}
    69 	}
    78 
    70 
    79 EXPORT_C TInt RFs::MountPlugin(const TDesC& aPluginName) const
    71 EXPORT_C TInt RFs::MountPlugin(const TDesC& aPluginName) const
    80 /**
    72 /**
   101 @see RFs::PluginName  
    93 @see RFs::PluginName  
   102 
    94 
   103 @capability DiskAdmin      
    95 @capability DiskAdmin      
   104 */
    96 */
   105 	{
    97 	{
   106 	OstTrace1(TRACE_BORDER, EFSRV_EFSMOUNTPLUGIN1, "sess %x", Handle());
    98 	TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsMountPlugin1, MODULEUID, Handle(), aPluginName);
   107 	OstTraceData(TRACE_BORDER, EFSRV_EFSMOUNTPLUGIN1_EPLUGINNAME, "PluginName %S", aPluginName.Ptr(), aPluginName.Length()<<1);
       
   108 
    99 
   109 	TInt r = SendReceive(EFsMountPlugin,TIpcArgs(&aPluginName,KPluginAutoAttach,KPluginAutoLocate));
   100 	TInt r = SendReceive(EFsMountPlugin,TIpcArgs(&aPluginName,KPluginAutoAttach,KPluginAutoLocate));
   110 
   101 
   111 	OstTrace1(TRACE_BORDER, EFSRV_EFSMOUNTPLUGIN1RETURN, "r %d", r);
   102 	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsMountPlugin1Return, MODULEUID, r);
   112 
       
   113 	return r;
   103 	return r;
   114 	}
   104 	}
   115 
   105 
   116 EXPORT_C TInt RFs::MountPlugin(const TDesC& aPluginName,TInt aDrive) const
   106 EXPORT_C TInt RFs::MountPlugin(const TDesC& aPluginName,TInt aDrive) const
   117 /**
   107 /**
   139 @see RFs::PluginName 
   129 @see RFs::PluginName 
   140 
   130 
   141 @capability DiskAdmin      
   131 @capability DiskAdmin      
   142 */
   132 */
   143 	{
   133 	{
   144 	OstTraceExt2(TRACE_BORDER, EFSRV_EFSMOUNTPLUGIN2, "sess %x aDrive %d", (TUint) Handle(), (TUint) aDrive);
   134 	TRACEMULT3(UTF::EBorder, UTraceModuleEfsrv::EFsMountPlugin2, MODULEUID, Handle(), aPluginName, aDrive);
   145 	OstTraceData(TRACE_BORDER, EFSRV_EFSMOUNTPLUGIN2_EPLUGINNAME, "PluginName %S", aPluginName.Ptr(), aPluginName.Length()<<1);
       
   146 
   135 
   147 	TInt r = SendReceive(EFsMountPlugin,TIpcArgs(&aPluginName,aDrive,KPluginAutoLocate));
   136 	TInt r = SendReceive(EFsMountPlugin,TIpcArgs(&aPluginName,aDrive,KPluginAutoLocate));
   148 
   137 
   149 	OstTrace1(TRACE_BORDER, EFSRV_EFSMOUNTPLUGIN2RETURN, "r %d", r);
   138 	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsMountPlugin2Return, MODULEUID, r);
   150 
       
   151 	return r;
   139 	return r;
   152 	}
   140 	}
   153 
   141 
   154 EXPORT_C TInt RFs::MountPlugin(const TDesC& aPluginName,TInt aDrive, TInt aPos) const
   142 EXPORT_C TInt RFs::MountPlugin(const TDesC& aPluginName,TInt aDrive, TInt aPos) const
   155 /**
   143 /**
   185 @see RFs::PluginName 
   173 @see RFs::PluginName 
   186 @see RFs::MountPlugin(const TDesC& aPluginName,TInt aDrive)
   174 @see RFs::MountPlugin(const TDesC& aPluginName,TInt aDrive)
   187 @capability DiskAdmin        
   175 @capability DiskAdmin        
   188 */
   176 */
   189 	{
   177 	{
   190 	OstTraceExt3(TRACE_BORDER, EFSRV_EFSMOUNTPLUGIN3, "sess %x aDrive %d aPos %x", (TUint) Handle(), (TUint) aDrive, (TUint) aPos);
   178 	TRACEMULT4(UTF::EBorder, UTraceModuleEfsrv::EFsMountPlugin3, MODULEUID, Handle(), aPluginName, aDrive, aPos);
   191 	OstTraceData(TRACE_BORDER, EFSRV_EFSMOUNTPLUGIN3_EPLUGINNAME, "PluginName %S", aPluginName.Ptr(), aPluginName.Length()<<1);
       
   192 
   179 
   193 	TInt r = SendReceive(EFsMountPlugin,TIpcArgs(&aPluginName,aDrive,aPos));
   180 	TInt r = SendReceive(EFsMountPlugin,TIpcArgs(&aPluginName,aDrive,aPos));
   194 
   181 
   195 	OstTrace1(TRACE_BORDER, EFSRV_EFSMOUNTPLUGIN3RETURN, "r %d", r);
   182 	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsMountPlugin3Return, MODULEUID, r);
   196 
       
   197 	return r;
   183 	return r;
   198 	}
   184 	}
   199 
   185 
   200 EXPORT_C TInt RFs::DismountPlugin(const TDesC& aPluginName) const
   186 EXPORT_C TInt RFs::DismountPlugin(const TDesC& aPluginName) const
   201 /**
   187 /**
   212         
   198         
   213 @see RFs::PluginName  
   199 @see RFs::PluginName  
   214 @capability DiskAdmin       
   200 @capability DiskAdmin       
   215 */
   201 */
   216 	{
   202 	{
   217 	OstTrace1(TRACE_BORDER, EFSRV_EFSDISMOUNTPLUGIN1, "sess %x", Handle());
   203 	TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsDismountPlugin1, MODULEUID, Handle(), aPluginName);
   218 	OstTraceData(TRACE_BORDER, EFSRV_EFSDISMOUNTPLUGIN1_EPLUGINNAME, "PluginName %S", aPluginName.Ptr(), aPluginName.Length()<<1);
       
   219 
   204 
   220 	TInt r = SendReceive(EFsDismountPlugin,TIpcArgs(&aPluginName,KPluginAutoAttach,KPluginAutoLocate));
   205 	TInt r = SendReceive(EFsDismountPlugin,TIpcArgs(&aPluginName,KPluginAutoAttach,KPluginAutoLocate));
   221 
   206 
   222 	OstTrace1(TRACE_BORDER, EFSRV_EFSDISMOUNTPLUGIN1RETURN, "r %d", r);
   207 	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsDismountPlugin1Return, MODULEUID, r);
   223 
       
   224 	return r;
   208 	return r;
   225 	}
   209 	}
   226 
   210 
   227 
   211 
   228 EXPORT_C TInt RFs::DismountPlugin(const TDesC& aPluginName,TInt aDrive) const
   212 EXPORT_C TInt RFs::DismountPlugin(const TDesC& aPluginName,TInt aDrive) const
   247         
   231         
   248 @see RFs::PluginName  
   232 @see RFs::PluginName  
   249 @capability DiskAdmin       
   233 @capability DiskAdmin       
   250 */
   234 */
   251 	{
   235 	{
   252 	OstTraceExt2(TRACE_BORDER, EFSRV_EFSDISMOUNTPLUGIN2, "sess %x aDrive %d", (TUint) Handle(), (TUint) aDrive);
   236 	TRACEMULT3(UTF::EBorder, UTraceModuleEfsrv::EFsDismountPlugin2, MODULEUID, Handle(), aPluginName, aDrive);
   253 	OstTraceData(TRACE_BORDER, EFSRV_EFSDISMOUNTPLUGIN2_EPLUGINNAME, "PluginName %S", aPluginName.Ptr(), aPluginName.Length()<<1);
       
   254 
   237 
   255 	TInt r = SendReceive(EFsDismountPlugin,TIpcArgs(&aPluginName,aDrive,KPluginAutoLocate));
   238 	TInt r = SendReceive(EFsDismountPlugin,TIpcArgs(&aPluginName,aDrive,KPluginAutoLocate));
   256 
   239 
   257 	OstTrace1(TRACE_BORDER, EFSRV_EFSDISMOUNTPLUGIN2RETURN, "r %d", r);
   240 	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsDismountPlugin2Return, MODULEUID, r);
   258 
       
   259 	return r;
   241 	return r;
   260 	}
   242 	}
   261 
   243 
   262 EXPORT_C TInt RFs::DismountPlugin(const TDesC& aPluginName,TInt aDrive,TInt aPos) const
   244 EXPORT_C TInt RFs::DismountPlugin(const TDesC& aPluginName,TInt aDrive,TInt aPos) const
   263 /**
   245 /**
   285         
   267         
   286 @see RFs::PluginName   
   268 @see RFs::PluginName   
   287 @capability DiskAdmin      
   269 @capability DiskAdmin      
   288 */
   270 */
   289 	{
   271 	{
   290 	OstTraceExt3(TRACE_BORDER, EFSRV_EFSDISMOUNTPLUGIN3, "sess %x aDrive %d aPos %x", (TUint) Handle(), (TUint) aDrive, (TUint) aPos);
   272 	TRACEMULT4(UTF::EBorder, UTraceModuleEfsrv::EFsDismountPlugin3, MODULEUID, Handle(), aPluginName, aDrive, aPos);
   291 	OstTraceData(TRACE_BORDER, EFSRV_EFSDISMOUNTPLUGIN3_EPLUGINNAME, "PluginName %S", aPluginName.Ptr(), aPluginName.Length()<<1);
       
   292 
   273 
   293 	TInt r = SendReceive(EFsDismountPlugin,TIpcArgs(&aPluginName,aDrive,aPos));
   274 	TInt r = SendReceive(EFsDismountPlugin,TIpcArgs(&aPluginName,aDrive,aPos));
   294 
   275 
   295 	OstTrace1(TRACE_BORDER, EFSRV_EFSDISMOUNTPLUGIN3RETURN, "r %d", r);
   276 	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsDismountPlugin3Return, MODULEUID, r);
   296 
       
   297 	return r;
   277 	return r;
   298 	}
   278 	}
   299 
   279 
   300 
   280 
   301 EXPORT_C TInt RFs::PluginName(TDes& aPluginName,TInt aDrive,TInt aPos)
   281 EXPORT_C TInt RFs::PluginName(TDes& aPluginName,TInt aDrive,TInt aPos)
   311 
   291 
   312 @return KErrNone, if successful;
   292 @return KErrNone, if successful;
   313         KErrNotFound if the plugin name is not found;
   293         KErrNotFound if the plugin name is not found;
   314 */
   294 */
   315 	{
   295 	{
   316 	OstTraceExt3(TRACE_BORDER, EFSRV_EFSPLUGINNAME, "sess %x aDrive %d aPos %x", (TUint) Handle(), (TUint) aDrive, (TUint) aPos);
   296 	TRACE3(UTF::EBorder, UTraceModuleEfsrv::EFsPluginName, MODULEUID, Handle(), aDrive, aPos);
   317 
   297 
   318 	TInt r = SendReceive(EFsPluginName,TIpcArgs(&aPluginName,aDrive,aPos));
   298 	TInt r = SendReceive(EFsPluginName,TIpcArgs(&aPluginName,aDrive,aPos));
   319 
   299 
   320 	OstTraceData(TRACE_BORDER, EFSRV_EFSPLUGINNAME_EPLUGINNAME, "PluginName %S", aPluginName.Ptr(), aPluginName.Length()<<1);
   300 	TRACERETMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsPluginName, MODULEUID, r, aPluginName);
   321 
       
   322 	OstTrace1(TRACE_BORDER, EFSRV_EFSPLUGINNAMERETURN, "r %d", r);
       
   323 
       
   324 	return r;
   301 	return r;
   325 	}
   302 	}
   326 
   303 
   327 EXPORT_C TInt RPlugin::Open(RFs& aFs, TInt aPos)
   304 EXPORT_C TInt RPlugin::Open(RFs& aFs, TInt aPos)
   328 /**
   305 /**
   334 @prama  aPos: Unique position of the plugin
   311 @prama  aPos: Unique position of the plugin
   335 @return KErrNotFound if it didn't find the plugin, else KErrNone
   312 @return KErrNotFound if it didn't find the plugin, else KErrNone
   336 
   313 
   337 */
   314 */
   338 	{
   315 	{
   339 	OstTraceExt2(TRACE_BORDER, EFSRV_EPLUGINOPEN, "sess %x aPos %x", (TUint) aFs.Handle(), (TUint) aPos);
   316 	TRACE2(UTF::EBorder, UTraceModuleEfsrv::EPluginOpen, MODULEUID, aFs.Handle(), aPos);
   340 
   317 
   341 	TInt r = CreateSubSession(aFs,EFsPluginOpen,TIpcArgs(aPos,0,0));
   318 	TInt r = CreateSubSession(aFs,EFsPluginOpen,TIpcArgs(aPos,0,0));
   342 
   319 
   343 	OstTraceExt2(TRACE_BORDER, EFSRV_EPLUGINOPENRETURN, "r %d subs %x", (TUint) r, (TUint) SubSessionHandle());
   320 	TRACERET2(UTF::EBorder, UTraceModuleEfsrv::EPluginOpenReturn, MODULEUID, r, SubSessionHandle());
   344 
       
   345 	return r;
   321 	return r;
   346 	}
   322 	}
   347 
   323 
   348 EXPORT_C void RPlugin::Close()
   324 EXPORT_C void RPlugin::Close()
   349 /**
   325 /**
   350 @internalTechnology
   326 @internalTechnology
   351 
   327 
   352 Closes a plugin 
   328 Closes a plugin 
   353 */
   329 */
   354 	{
   330 	{
   355 	OstTraceExt2(TRACE_BORDER, EFSRV_EPLUGINCLOSE, "sess %x subs %x", (TUint) Session().Handle(), (TUint) SubSessionHandle());
   331 	TRACE2(UTF::EBorder, UTraceModuleEfsrv::EPluginClose, MODULEUID, Session().Handle(), SubSessionHandle());
   356 
   332 
   357 	CloseSubSession(EFsPluginSubClose);
   333 	CloseSubSession(EFsPluginSubClose);
   358 
   334 
   359 	OstTrace0(TRACE_BORDER, EFSRV_EPLUGINCLOSERETURN, "");
   335 	TRACE0(UTF::EBorder, UTraceModuleEfsrv::EPluginCloseReturn, MODULEUID);
   360 	}
   336 	}
   361 
   337 
   362 EXPORT_C void RPlugin::DoRequest(TInt aReqNo, TRequestStatus& aStatus) const
   338 EXPORT_C void RPlugin::DoRequest(TInt aReqNo, TRequestStatus& aStatus) const
   363 /**
   339 /**
   364 @internalTechnology
   340 @internalTechnology
   367 
   343 
   368 @param aReqNo: Number of the request
   344 @param aReqNo: Number of the request
   369 @param aStatus: status of the request
   345 @param aStatus: status of the request
   370 */
   346 */
   371 	{
   347 	{
   372 	OstTraceExt4(TRACE_BORDER, EFSRV_EPLUGINDOREQUEST1, "sess %x subs %x aReqNo %d status %x", (TUint) Session().Handle(), (TUint) SubSessionHandle(), (TUint) aReqNo, (TUint) &aStatus);
   348 	TRACE4(UTF::EBorder, UTraceModuleEfsrv::EPluginDoRequest1, MODULEUID, Session().Handle(), SubSessionHandle(), aReqNo, &aStatus);
   373 
   349 
   374 	aStatus=KRequestPending;
   350 	aStatus=KRequestPending;
   375 	SendReceive(EFsPluginDoRequest, TIpcArgs(aReqNo, NULL, NULL), aStatus);
   351 	SendReceive(EFsPluginDoRequest, TIpcArgs(aReqNo, NULL, NULL), aStatus);
   376 
   352 
   377 	OstTrace0(TRACE_BORDER, EFSRV_EPLUGINDOREQUEST1RETURN, "");
   353 	TRACE0(UTF::EBorder, UTraceModuleEfsrv::EPluginDoRequest1Return, MODULEUID);
   378 	}
   354 	}
   379 
   355 
   380 EXPORT_C void RPlugin::DoRequest(TInt aReqNo, TRequestStatus& aStatus, TDes8& a1) const
   356 EXPORT_C void RPlugin::DoRequest(TInt aReqNo, TRequestStatus& aStatus, TDes8& a1) const
   381 /**
   357 /**
   382 @internalTechnology
   358 @internalTechnology
   386 @param aReqNo: Number of the request
   362 @param aReqNo: Number of the request
   387 @param aStatus: status of the request
   363 @param aStatus: status of the request
   388 @param a1: returning value from plugin
   364 @param a1: returning value from plugin
   389 */
   365 */
   390 	{
   366 	{
   391 	OstTraceExt5(TRACE_BORDER, EFSRV_EPLUGINDOREQUEST2, "sess %x subs %x aReqNo %d status %x a1 %x", (TUint) Session().Handle(), (TUint) SubSessionHandle(), (TUint) aReqNo, (TUint) &aStatus, (TUint) &a1);
   367 	TRACE5(UTF::EBorder, UTraceModuleEfsrv::EPluginDoRequest2, MODULEUID, Session().Handle(), SubSessionHandle(), aReqNo, &aStatus, &a1);
   392 
   368 
   393 	aStatus=KRequestPending;
   369 	aStatus=KRequestPending;
   394 	SendReceive(EFsPluginDoRequest, TIpcArgs(aReqNo, &a1, NULL), aStatus);
   370 	SendReceive(EFsPluginDoRequest, TIpcArgs(aReqNo, &a1, NULL), aStatus);
   395 
   371 
   396 	OstTrace0(TRACE_BORDER, EFSRV_EPLUGINDOREQUEST2RETURN, "");
   372 	TRACE0(UTF::EBorder, UTraceModuleEfsrv::EPluginDoRequest2Return, MODULEUID);
   397 	}
   373 	}
   398 
   374 
   399 EXPORT_C void RPlugin::DoRequest(TInt aReqNo, TRequestStatus& aStatus, TDes8& a1, TDes8& a2) const
   375 EXPORT_C void RPlugin::DoRequest(TInt aReqNo, TRequestStatus& aStatus, TDes8& a1, TDes8& a2) const
   400 /**
   376 /**
   401 @internalTechnology
   377 @internalTechnology
   404 @param aStatus: status of the request
   380 @param aStatus: status of the request
   405 @param a1: returning value from plugin
   381 @param a1: returning value from plugin
   406 @param a2: 2nd returning value from plugin
   382 @param a2: 2nd returning value from plugin
   407 */
   383 */
   408 	{
   384 	{
   409 	OstTraceExt5(TRACE_BORDER, EFSRV_EPLUGINDOREQUEST3, "sess %x subs %x aReqNo %d a1 %x a2 %x", (TUint) Session().Handle(), (TUint) SubSessionHandle(), (TUint) aReqNo, (TUint) &a1, (TUint) &a2);
   385 	TRACE6(UTF::EBorder, UTraceModuleEfsrv::EPluginDoRequest3, MODULEUID, Session().Handle(), SubSessionHandle(), aReqNo, &aStatus, &a1, &a2);
   410 
   386 
   411 	aStatus=KRequestPending;
   387 	aStatus=KRequestPending;
   412 	SendReceive(EFsPluginDoRequest, TIpcArgs(aReqNo, &a1, &a2), aStatus);
   388 	SendReceive(EFsPluginDoRequest, TIpcArgs(aReqNo, &a1, &a2), aStatus);
   413 
   389 
   414 	OstTrace0(TRACE_BORDER, EFSRV_EPLUGINDOREQUEST3RETURN, "");
   390 	TRACE0(UTF::EBorder, UTraceModuleEfsrv::EPluginDoRequest3Return, MODULEUID);
   415 	}
   391 	}
   416 
   392 
   417 EXPORT_C TInt RPlugin::DoControl(TInt aFunction) const
   393 EXPORT_C TInt RPlugin::DoControl(TInt aFunction) const
   418 /**
   394 /**
   419 @internalTechnology
   395 @internalTechnology
   421 Client requests a synchronous operation
   397 Client requests a synchronous operation
   422 
   398 
   423 @param	aFunction: The operation to be handled
   399 @param	aFunction: The operation to be handled
   424 */
   400 */
   425 	{
   401 	{
   426 	OstTraceExt3(TRACE_BORDER, EFSRV_EPLUGINDOCONTROL1, "sess %x subs %x aFunction %d", (TUint) Session().Handle(), (TUint) SubSessionHandle(), (TUint) aFunction);
   402 	TRACE3(UTF::EBorder, UTraceModuleEfsrv::EPluginDoControl1, MODULEUID, Session().Handle(), SubSessionHandle(), aFunction);
   427 
   403 
   428 	TInt r = SendReceive(EFsPluginDoControl,TIpcArgs(aFunction,0,0));
   404 	TInt r = SendReceive(EFsPluginDoControl,TIpcArgs(aFunction,0,0));
   429 
   405 
   430 	OstTrace1(TRACE_BORDER, EFSRV_EPLUGINDOCONTROL1RETURN, "r %d", r);
   406 	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EPluginDoControl1Return, MODULEUID, r);
   431 
       
   432 	return r;
   407 	return r;
   433 	}
   408 	}
   434 
   409 
   435 EXPORT_C TInt RPlugin::DoControl(TInt aFunction, TDes8& a1) const
   410 EXPORT_C TInt RPlugin::DoControl(TInt aFunction, TDes8& a1) const
   436 /**
   411 /**
   440 
   415 
   441 @param	aFunction: The operation to be handled
   416 @param	aFunction: The operation to be handled
   442 @param	a1: returned buffer from plugin on completion of the request
   417 @param	a1: returned buffer from plugin on completion of the request
   443 */
   418 */
   444 	{
   419 	{
   445 	OstTraceExt4(TRACE_BORDER, EFSRV_EPLUGINDOCONTROL2, "sess %x subs %x aFunction %d a1 %x", (TUint) Session().Handle(), (TUint) SubSessionHandle(), (TUint) aFunction, (TUint) &a1);
   420 	TRACE4(UTF::EBorder, UTraceModuleEfsrv::EPluginDoControl2, MODULEUID, Session().Handle(), SubSessionHandle(), aFunction, &a1);
   446 
   421 
   447 	TInt r = SendReceive(EFsPluginDoControl,TIpcArgs(aFunction,&a1,0));
   422 	TInt r = SendReceive(EFsPluginDoControl,TIpcArgs(aFunction,&a1,0));
   448 
   423 
   449 	OstTrace1(TRACE_BORDER, EFSRV_EPLUGINDOCONTROL2RETURN, "r %d", r);
   424 	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EPluginDoControl2Return, MODULEUID, r);
   450 
       
   451 	return r;
   425 	return r;
   452 	}
   426 	}
   453 
   427 
   454 EXPORT_C TInt RPlugin::DoControl(TInt aFunction, TDes8& a1, TDes8& a2) const
   428 EXPORT_C TInt RPlugin::DoControl(TInt aFunction, TDes8& a1, TDes8& a2) const
   455 /**
   429 /**
   460 @param	aFunction: The operation to be handled
   434 @param	aFunction: The operation to be handled
   461 @param	a1: returned buffer from plugin on completion of the request
   435 @param	a1: returned buffer from plugin on completion of the request
   462 @param  a2: 2nd returned buffer from plugin on completion of the request
   436 @param  a2: 2nd returned buffer from plugin on completion of the request
   463 */
   437 */
   464 	{
   438 	{
   465 	OstTraceExt5(TRACE_BORDER, EFSRV_EPLUGINDOCONTROL3, "sess %x subs %x aFunction %d a1 %x a2 %x", (TUint) Session().Handle(), (TUint) SubSessionHandle(), (TUint) aFunction, (TUint) &a1, (TUint) &a2);
   439 	TRACE5(UTF::EBorder, UTraceModuleEfsrv::EPluginDoControl3, MODULEUID, Session().Handle(), SubSessionHandle(), aFunction, &a1, &a2);
   466 
   440 
   467 	TInt r = SendReceive(EFsPluginDoControl,TIpcArgs(aFunction,&a1,&a2));
   441 	TInt r = SendReceive(EFsPluginDoControl,TIpcArgs(aFunction,&a1,&a2));
   468 
   442 
   469 	OstTrace1(TRACE_BORDER, EFSRV_EPLUGINDOCONTROL3RETURN, "r %d", r);
   443 	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EPluginDoControl3Return, MODULEUID, r);
   470 
       
   471 	return r;
   444 	return r;
   472 	}
   445 	}
   473 
   446 
   474 EXPORT_C void RPlugin::DoCancel(TUint aReqMask) const
   447 EXPORT_C void RPlugin::DoCancel(TUint aReqMask) const
   475 /**
   448 /**
   478 Cancels a request
   451 Cancels a request
   479 
   452 
   480 @param	aReqMask: the bit mask for the operation to be cancelled
   453 @param	aReqMask: the bit mask for the operation to be cancelled
   481 */
   454 */
   482 	{
   455 	{
   483 	OstTraceExt3(TRACE_BORDER, EFSRV_EPLUGINDOCANCEL, "sess %x subs %x aReqMask %x", (TUint) Session().Handle(), (TUint) SubSessionHandle(), (TUint) aReqMask);
   456 	TRACE3(UTF::EBorder, UTraceModuleEfsrv::EPluginDoCancel, MODULEUID, Session().Handle(), SubSessionHandle(), aReqMask);
   484 
   457 
   485 	SendReceive(EFsPluginDoCancel,TIpcArgs(KMaxTInt,aReqMask,0));
   458 	SendReceive(EFsPluginDoCancel,TIpcArgs(KMaxTInt,aReqMask,0));
   486 
   459 
   487 	OstTrace0(TRACE_BORDER, EFSRV_EPLUGINDOCANCELRETURN, "");
   460 	TRACE0(UTF::EBorder, UTraceModuleEfsrv::EPluginDoCancelReturn, MODULEUID);
   488 	}
   461 	}
   489 
   462