source3/smbd/dmapi.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    DMAPI Support routines
   4
   5    Copyright (C) James Peach 2006
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include "includes.h"
  22 #include "smbd/smbd.h"
  23 #include "smbd/globals.h"
  24
  25 #undef DBGC_CLASS
  26 #define DBGC_CLASS DBGC_DMAPI
  27
  28 #ifndef USE_DMAPI
  29
  30 uint32_t dmapi_file_flags(const char * const path) { return 0; }
  31 bool dmapi_have_session(void) { return False; }
  32 const void * dmapi_get_current_session(void) { return NULL; }
  33
  34 #else /* USE_DMAPI */
  35
  36 #ifdef HAVE_XFS_DMAPI_H
  37 #include <xfs/dmapi.h>
  38 #elif defined(HAVE_SYS_DMI_H)
  39 #include <sys/dmi.h>
  40 #elif defined(HAVE_SYS_JFSDMAPI_H)
  41 #include <sys/jfsdmapi.h>
  42 #elif defined(HAVE_SYS_DMAPI_H)
  43 #include <sys/dmapi.h>
  44 #elif defined(HAVE_DMAPI_H)
  45 #include <dmapi.h>
  46 #endif
  47
  48 #define DMAPI_SESSION_NAME "samba"
  49 #define DMAPI_TRACE 10
  50
  51 struct smbd_dmapi_context {
  52         dm_sessid_t session;
  53         unsigned session_num;
  54 };
  55
  56 /*
  57    Initialise DMAPI session. The session is persistent kernel state,
  58    so it might already exist, in which case we merely want to
  59    reconnect to it. This function should be called as root.
  60 */
  61 static int dmapi_init_session(struct smbd_dmapi_context *ctx)
  62 {
  63         char    buf[DM_SESSION_INFO_LEN];
  64         size_t  buflen;
  65         uint        nsessions = 5;
  66         dm_sessid_t *sessions = NULL;
  67         char    *version;
  68         char    *session_name;
  69         TALLOC_CTX *tmp_ctx = talloc_new(NULL);
  70
  71         int i, err;
  72
  73         if (ctx->session_num == 0) {
  74                 session_name = talloc_strdup(tmp_ctx, DMAPI_SESSION_NAME);
  75         } else {
  76                 session_name = talloc_asprintf(tmp_ctx, "%s%u", DMAPI_SESSION_NAME,
  77                                                ctx->session_num);
  78         }
  79
  80         if (session_name == NULL) {
  81                 DEBUG(0,("Out of memory in dmapi_init_session\n"));
  82                 talloc_free(tmp_ctx);
  83                 return -1;
  84         }
  85
  86
  87         if (dm_init_service(&version) < 0) {
  88                 DEBUG(0, ("dm_init_service failed - disabling DMAPI\n"));
  89                 talloc_free(tmp_ctx);
  90                 return -1;
  91         }
  92
  93         ZERO_STRUCT(buf);
  94
  95         /* Fetch kernel DMAPI sessions until we get any of them */
  96         do {
  97                 dm_sessid_t *new_sessions;
  98                 nsessions *= 2;
  99                 new_sessions = talloc_realloc(tmp_ctx, sessions,
 100                                                     dm_sessid_t, nsessions);
 101                 if (new_sessions == NULL) {
 102                         talloc_free(tmp_ctx);
 103                         return -1;
 104                 }
 105
 106                 sessions = new_sessions;
 107                 err = dm_getall_sessions(nsessions, sessions, &nsessions);
 108         } while (err == -1 && errno == E2BIG);
 109
 110         if (err == -1) {
 111                 DEBUGADD(DMAPI_TRACE,
 112                         ("failed to retrieve DMAPI sessions: %s\n",
 113                         strerror(errno)));
 114                 talloc_free(tmp_ctx);
 115                 return -1;
 116         }
 117
 118         /* Look through existing kernel DMAPI sessions to find out ours */
 119         for (i = 0; i < nsessions; ++i) {
 120                 err = dm_query_session(sessions[i], sizeof(buf), buf, &buflen);
 121                 buf[sizeof(buf) - 1] = '\0';
 122                 if (err == 0 && strcmp(session_name, buf) == 0) {
 123                         ctx->session = sessions[i];
 124                         DEBUGADD(DMAPI_TRACE,
 125                                 ("attached to existing DMAPI session "
 126                                  "named '%s'\n", buf));
 127                         break;
 128                 }
 129         }
 130
 131         /* No session already defined. */
 132         if (ctx->session == DM_NO_SESSION) {
 133                 err = dm_create_session(DM_NO_SESSION,
 134                                         session_name,
 135                                         &ctx->session);
 136                 if (err < 0) {
 137                         DEBUGADD(DMAPI_TRACE,
 138                                 ("failed to create new DMAPI session: %s\n",
 139                                 strerror(errno)));
 140                         ctx->session = DM_NO_SESSION;
 141                         talloc_free(tmp_ctx);
 142                         return -1;
 143                 }
 144
 145                 DEBUG(0, ("created new DMAPI session named '%s' for %s\n",
 146                           session_name, version));
 147         }
 148
 149         if (ctx->session != DM_NO_SESSION) {
 150                 set_effective_capability(DMAPI_ACCESS_CAPABILITY);
 151         }
 152
 153         /*
 154            Note that we never end the DMAPI session. It gets re-used if possiblie.
 155            DMAPI session is a kernel resource that is usually lives until server reboot
 156            and doesn't get destroed when an application finishes.
 157
 158            However, we free list of references to DMAPI sessions we've got from the kernel
 159            as it is not needed anymore once we have found (or created) our session.
 160          */
 161
 162         talloc_free(tmp_ctx);
 163         return 0;
 164 }
 165
 166 /*
 167   Return a pointer to our DMAPI session, if available.
 168   This assumes that you have called dmapi_have_session() first.
 169 */
 170 const void *dmapi_get_current_session(void)
 171 {
 172         if (!dmapi_ctx) {
 173                 return NULL;
 174         }
 175
 176         if (dmapi_ctx->session == DM_NO_SESSION) {
 177                 return NULL;
 178         }
 179
 180         return (void *)&dmapi_ctx->session;
 181 }
 182
 183 /*
 184   dmapi_have_session() must be the first DMAPI call you make in Samba. It will
 185   initialize DMAPI, if available, and tell you if you can get a DMAPI session.
 186   This should be called in the client-specific child process.
 187 */
 188
 189 bool dmapi_have_session(void)
 190 {
 191         if (!dmapi_ctx) {
 192                 dmapi_ctx = talloc(NULL, struct smbd_dmapi_context);
 193                 if (!dmapi_ctx) {
 194                         exit_server("unable to allocate smbd_dmapi_context");
 195                 }
 196                 dmapi_ctx->session = DM_NO_SESSION;
 197                 dmapi_ctx->session_num = 0;
 198
 199                 become_root();
 200                 dmapi_init_session(dmapi_ctx);
 201                 unbecome_root();
 202
 203         }
 204
 205         return dmapi_ctx->session != DM_NO_SESSION;
 206 }
 207
 208 /*
 209   only call this when you get back an EINVAL error indicating that the
 210   session you are using is invalid. This destroys the existing session
 211   and creates a new one.
 212  */
 213 bool dmapi_new_session(void)
 214 {
 215         if (dmapi_have_session()) {
 216                 /* try to destroy the old one - this may not succeed */
 217                 dm_destroy_session(dmapi_ctx->session);
 218         }
 219         dmapi_ctx->session = DM_NO_SESSION;
 220         become_root();
 221         dmapi_ctx->session_num++;
 222         dmapi_init_session(dmapi_ctx);
 223         unbecome_root();
 224         return dmapi_ctx->session != DM_NO_SESSION;
 225 }
 226
 227 /*
 228     only call this when exiting from master smbd process. DMAPI sessions
 229     are long-lived kernel resources we ought to share across smbd processes.
 230     However, we must free them when all smbd processes are finished to
 231     allow other subsystems clean up properly. Not freeing DMAPI session
 232     blocks certain HSM implementations from proper shutdown.
 233 */
 234 bool dmapi_destroy_session(void)
 235 {
 236         if (!dmapi_ctx) {
 237                 return true;
 238         }
 239         if (dmapi_ctx->session != DM_NO_SESSION) {
 240                 become_root();
 241                 if (0 == dm_destroy_session(dmapi_ctx->session)) {
 242                         dmapi_ctx->session_num--;
 243                         dmapi_ctx->session = DM_NO_SESSION;
 244                 } else {
 245                         DEBUG(0,("Couldn't destroy DMAPI session: %s\n",
 246                                  strerror(errno)));
 247                 }
 248                 unbecome_root();
 249         }
 250         return dmapi_ctx->session == DM_NO_SESSION;
 251 }
 252
 253
 254 /*
 255    This is default implementation of dmapi_file_flags() that is
 256    called from VFS is_offline() call to know whether file is offline.
 257    For GPFS-specific version see modules/vfs_tsmsm.c. It might be
 258    that approach on querying existence of a specific attribute that
 259    is used in vfs_tsmsm.c will work with other DMAPI-based HSM
 260    implementations as well.
 261 */
 262 uint32_t dmapi_file_flags(const char * const path)
 263 {
 264         int             err;
 265         dm_eventset_t   events = {0};
 266         uint            nevents;
 267
 268         dm_sessid_t     dmapi_session;
 269         dm_sessid_t     *dmapi_session_ptr;
 270         const void      *_dmapi_session_ptr;
 271         void            *dm_handle = NULL;
 272         size_t          dm_handle_len = 0;
 273
 274         uint32_t        flags = 0;
 275
 276         _dmapi_session_ptr = dmapi_get_current_session();
 277         if (_dmapi_session_ptr == NULL) {
 278                 return 0;
 279         }
 280
 281         dmapi_session_ptr = discard_const_p(dm_sessid_t, _dmapi_session_ptr);
 282         dmapi_session = *dmapi_session_ptr;
 283         if (dmapi_session == DM_NO_SESSION) {
 284                 return 0;
 285         }
 286
 287         /* AIX has DMAPI but no POSIX capabilities support. In this case,
 288          * we need to be root to do DMAPI manipulations.
 289          */
 290 #ifndef HAVE_POSIX_CAPABILITIES
 291         become_root();
 292 #endif
 293
 294         err = dm_path_to_handle(discard_const_p(char, path),
 295                 &dm_handle, &dm_handle_len);
 296         if (err < 0) {
 297                 DEBUG(DMAPI_TRACE, ("dm_path_to_handle(%s): %s\n",
 298                             path, strerror(errno)));
 299
 300                 if (errno != EPERM) {
 301                         goto done;
 302                 }
 303
 304                 /* Linux capabilities are broken in that changing our
 305                  * user ID will clobber out effective capabilities irrespective
 306                  * of whether we have set PR_SET_KEEPCAPS. Fortunately, the
 307                  * capabilities are not removed from our permitted set, so we
 308                  * can re-acquire them if necessary.
 309                  */
 310
 311                 set_effective_capability(DMAPI_ACCESS_CAPABILITY);
 312
 313                 err = dm_path_to_handle(discard_const_p(char, path),
 314                         &dm_handle, &dm_handle_len);
 315                 if (err < 0) {
 316                         DEBUG(DMAPI_TRACE,
 317                             ("retrying dm_path_to_handle(%s): %s\n",
 318                             path, strerror(errno)));
 319                         goto done;
 320                 }
 321         }
 322
 323         err = dm_get_eventlist(dmapi_session, dm_handle, dm_handle_len,
 324                 DM_NO_TOKEN, DM_EVENT_MAX, &events, &nevents);
 325         if (err < 0) {
 326                 DEBUG(DMAPI_TRACE, ("dm_get_eventlist(%s): %s\n",
 327                             path, strerror(errno)));
 328                 dm_handle_free(dm_handle, dm_handle_len);
 329                 goto done;
 330         }
 331
 332         /* We figure that the only reason a DMAPI application would be
 333          * interested in trapping read events is that part of the file is
 334          * offline.
 335          */
 336         DEBUG(DMAPI_TRACE, ("DMAPI event list for %s\n", path));
 337         if (DMEV_ISSET(DM_EVENT_READ, events)) {
 338                 flags = FILE_ATTRIBUTE_OFFLINE;
 339         }
 340
 341         dm_handle_free(dm_handle, dm_handle_len);
 342
 343         if (flags & FILE_ATTRIBUTE_OFFLINE) {
 344                 DEBUG(DMAPI_TRACE, ("%s is OFFLINE\n", path));
 345         }
 346
 347 done:
 348
 349 #ifndef HAVE_POSIX_CAPABILITIES
 350         unbecome_root();
 351 #endif
 352
 353         return flags;
 354 }
 355
 356
 357 #endif /* USE_DMAPI */