source3/lib/sysquotas_xfs.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    System QUOTA function wrappers for XFS
   4    Copyright (C) Stefan (metze) Metzmacher      2003
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20
  21 #include "includes.h"
  22
  23 #undef DBGC_CLASS
  24 #define DBGC_CLASS DBGC_QUOTA
  25
  26 #if defined(HAVE_SYS_QUOTAS) && defined(HAVE_XFS_QUOTAS)
  27
  28 #ifdef HAVE_SYS_QUOTA_H
  29 #include <sys/quota.h>
  30 #endif
  31
  32 /* this one should actually come from glibc: */
  33 /* #include "samba_linux_quota.h" */
  34
  35 #ifdef HAVE_XFS_XQM_H
  36 #include <xfs/xqm.h>
  37 #endif
  38
  39 #define HAVE_GROUP_QUOTA
  40
  41 /* on IRIX */
  42 #ifndef Q_XQUOTAON
  43 #define Q_XQUOTAON Q_QUOTAON
  44 #endif /* Q_XQUOTAON */
  45 #ifndef Q_XQUOTAOFF
  46 #define Q_XQUOTAOFF Q_QUOTAOFF
  47 #endif /* Q_XQUOTAOFF */
  48 #ifndef Q_XGETQSTAT
  49 #define Q_XGETQSTAT Q_GETQSTAT
  50 #endif /* Q_XGETQSTAT */
  51
  52 /* currently doesn't support Group and Project quotas on IRIX
  53  */
  54
  55 #ifndef QCMD
  56 #define QCMD(x,y) x
  57 #endif
  58
  59 /*
  60  * IRIX has BBSIZE in <sys/param.h>
  61  */
  62 #ifndef BBSHIFT
  63 #define BBSHIFT         9
  64 #endif /* BBSHIFT */
  65 #ifndef BBSIZE
  66 #define BBSIZE          (1<<BBSHIFT)
  67 #endif /* BBSIZE */
  68
  69 /****************************************************************************
  70  Abstract out the XFS Quota Manager quota get call.
  71 ****************************************************************************/
  72 int sys_get_xfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
  73 {
  74         int ret = -1;
  75         uint32_t qflags = 0;
  76         uint64_t bsize = (uint64_t)BBSIZE;
  77         struct fs_disk_quota D;
  78         struct fs_quota_stat F;
  79         ZERO_STRUCT(D);
  80         ZERO_STRUCT(F);
  81
  82         if (!bdev||!dp)
  83                 smb_panic("sys_get_xfs_quota: called with NULL pointer");
  84
  85         ZERO_STRUCT(*dp);
  86         dp->qtype = qtype;
  87
  88         switch (qtype) {
  89                 case SMB_USER_QUOTA_TYPE:
  90                         DEBUG(10,("sys_get_xfs_quota: path[%s] bdev[%s] SMB_USER_QUOTA_TYPE uid[%u]\n",
  91                                 path, bdev, (unsigned)id.uid));
  92
  93                         ret=quotactl(QCMD(Q_XGETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D);
  94                         /* XFS fails with ENOENT if the user has no
  95                          * quota. Our protocol in that case is to
  96                          * succeed and return 0 as quota.
  97                          */
  98                         if (ret != 0 && errno != ENOENT) {
  99                                 return ret;
 100                         }
 101
 102                         ret = 0;
 103                         break;
 104 #ifdef HAVE_GROUP_QUOTA
 105                 case SMB_GROUP_QUOTA_TYPE:
 106                         DEBUG(10,("sys_get_xfs_quota: path[%s] bdev[%s] SMB_GROUP_QUOTA_TYPE gid[%u]\n",
 107                                 path, bdev, (unsigned)id.gid));
 108
 109                         ret=quotactl(QCMD(Q_XGETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D);
 110                         /* XFS fails with ENOENT if the user has no
 111                          * quota. Our protocol in that case is to
 112                          * succeed and return 0 as quota.
 113                          */
 114                         if (ret != 0 && errno != ENOENT) {
 115                                 return ret;
 116                         }
 117                         break;
 118 #endif /* HAVE_GROUP_QUOTA */
 119                 case SMB_USER_FS_QUOTA_TYPE:
 120                         DEBUG(10,("sys_get_xfs_quota: path[%s] bdev[%s] SMB_USER_FS_QUOTA_TYPE (uid[%u])\n",
 121                                 path, bdev, (unsigned)id.uid));
 122
 123                         quotactl(QCMD(Q_XGETQSTAT,USRQUOTA), bdev, -1, (caddr_t)&F);
 124
 125                         if (F.qs_flags & XFS_QUOTA_UDQ_ENFD) {
 126                                 qflags |= QUOTAS_DENY_DISK;
 127                         }
 128                         else if (F.qs_flags & XFS_QUOTA_UDQ_ACCT) {
 129                                 qflags |= QUOTAS_ENABLED;
 130                         }
 131
 132                         ret = 0;
 133
 134                         break;
 135 #ifdef HAVE_GROUP_QUOTA
 136                 case SMB_GROUP_FS_QUOTA_TYPE:
 137                         DEBUG(10,("sys_get_xfs_quota: path[%s] bdev[%s] SMB_GROUP_FS_QUOTA_TYPE (gid[%u])\n",
 138                                 path, bdev, (unsigned)id.gid));
 139
 140                         quotactl(QCMD(Q_XGETQSTAT,GRPQUOTA), bdev, -1, (caddr_t)&F);
 141
 142                         if (F.qs_flags & XFS_QUOTA_GDQ_ENFD) {
 143                                 qflags |= QUOTAS_DENY_DISK;
 144                         }
 145                         else if (F.qs_flags & XFS_QUOTA_GDQ_ACCT) {
 146                                 qflags |= QUOTAS_ENABLED;
 147                         }
 148
 149                         ret = 0;
 150
 151                         break;
 152 #endif /* HAVE_GROUP_QUOTA */
 153                 default:
 154                         errno = ENOSYS;
 155                         return -1;
 156         }
 157
 158         dp->bsize = bsize;
 159         dp->softlimit = (uint64_t)D.d_blk_softlimit;
 160         dp->hardlimit = (uint64_t)D.d_blk_hardlimit;
 161         dp->ihardlimit = (uint64_t)D.d_ino_hardlimit;
 162         dp->isoftlimit = (uint64_t)D.d_ino_softlimit;
 163         dp->curinodes = (uint64_t)D.d_icount;
 164         dp->curblocks = (uint64_t)D.d_bcount;
 165         dp->qflags = qflags;
 166
 167         return ret;
 168 }
 169
 170 /****************************************************************************
 171  Abstract out the XFS Quota Manager quota set call.
 172 ****************************************************************************/
 173 int sys_set_xfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
 174 {
 175         int ret = -1;
 176         uint32_t qflags = 0;
 177         uint64_t bsize = (uint64_t)BBSIZE;
 178         struct fs_disk_quota D;
 179         struct fs_quota_stat F;
 180         int q_on = 0;
 181         int q_off = 0;
 182         ZERO_STRUCT(D);
 183         ZERO_STRUCT(F);
 184
 185         if (!bdev||!dp)
 186                 smb_panic("sys_set_xfs_quota: called with NULL pointer");
 187
 188         if (bsize == dp->bsize) {
 189                 D.d_blk_softlimit = dp->softlimit;
 190                 D.d_blk_hardlimit = dp->hardlimit;
 191         } else {
 192                 D.d_blk_softlimit = (dp->softlimit*dp->bsize)/bsize;
 193                 D.d_blk_hardlimit = (dp->hardlimit*dp->bsize)/bsize;
 194         }
 195         D.d_ino_hardlimit = dp->ihardlimit;
 196         D.d_ino_softlimit = dp->isoftlimit;
 197
 198         qflags = dp->qflags;
 199
 200         switch (qtype) {
 201                 case SMB_USER_QUOTA_TYPE:
 202                         DEBUG(10,("sys_set_xfs_quota: path[%s] bdev[%s] SMB_USER_QUOTA_TYPE uid[%u]\n",
 203                                 path, bdev, (unsigned)id.uid));
 204
 205                         D.d_fieldmask |= FS_DQ_LIMIT_MASK;
 206                         ret = quotactl(QCMD(Q_XSETQLIM,USRQUOTA), bdev, id.uid, (caddr_t)&D);
 207                         break;
 208 #ifdef HAVE_GROUP_QUOTA
 209                 case SMB_GROUP_QUOTA_TYPE:
 210                         DEBUG(10,("sys_set_xfs_quota: path[%s] bdev[%s] SMB_GROUP_QUOTA_TYPE gid[%u]\n",
 211                                 path, bdev, (unsigned)id.gid));
 212
 213                         D.d_fieldmask |= FS_DQ_LIMIT_MASK;
 214                         ret = quotactl(QCMD(Q_XSETQLIM,GRPQUOTA), bdev, id.gid, (caddr_t)&D);
 215                         break;
 216 #endif /* HAVE_GROUP_QUOTA */
 217                 case SMB_USER_FS_QUOTA_TYPE:
 218                         DEBUG(10,("sys_set_xfs_quota: path[%s] bdev[%s] SMB_USER_FS_QUOTA_TYPE (uid[%u])\n",
 219                                 path, bdev, (unsigned)id.uid));
 220
 221                         quotactl(QCMD(Q_XGETQSTAT,USRQUOTA), bdev, -1, (caddr_t)&F);
 222
 223                         if (qflags & QUOTAS_DENY_DISK) {
 224                                 if (!(F.qs_flags & XFS_QUOTA_UDQ_ENFD))
 225                                         q_on |= XFS_QUOTA_UDQ_ENFD;
 226                                 if (!(F.qs_flags & XFS_QUOTA_UDQ_ACCT))
 227                                         q_on |= XFS_QUOTA_UDQ_ACCT;
 228
 229                                 if (q_on != 0) {
 230                                         ret = quotactl(QCMD(Q_XQUOTAON,USRQUOTA),bdev, -1, (caddr_t)&q_on);
 231                                 } else {
 232                                         ret = 0;
 233                                 }
 234
 235                         } else if (qflags & QUOTAS_ENABLED) {
 236                                 if (F.qs_flags & XFS_QUOTA_UDQ_ENFD)
 237                                         q_off |= XFS_QUOTA_UDQ_ENFD;
 238
 239                                 if (q_off != 0) {
 240                                         ret = quotactl(QCMD(Q_XQUOTAOFF,USRQUOTA),bdev, -1, (caddr_t)&q_off);
 241                                 } else {
 242                                         ret = 0;
 243                                 }
 244
 245                                 if (!(F.qs_flags & XFS_QUOTA_UDQ_ACCT))
 246                                         q_on |= XFS_QUOTA_UDQ_ACCT;
 247
 248                                 if (q_on != 0) {
 249                                         ret = quotactl(QCMD(Q_XQUOTAON,USRQUOTA),bdev, -1, (caddr_t)&q_on);
 250                                 } else {
 251                                         ret = 0;
 252                                 }
 253                         } else {
 254 #if 0
 255                         /* Switch on XFS_QUOTA_UDQ_ACCT didn't work!
 256                          * only swittching off XFS_QUOTA_UDQ_ACCT work
 257                          */
 258                                 if (F.qs_flags & XFS_QUOTA_UDQ_ENFD)
 259                                         q_off |= XFS_QUOTA_UDQ_ENFD;
 260                                 if (F.qs_flags & XFS_QUOTA_UDQ_ACCT)
 261                                         q_off |= XFS_QUOTA_UDQ_ACCT;
 262
 263                                 if (q_off !=0) {
 264                                         ret = quotactl(QCMD(Q_XQUOTAOFF,USRQUOTA),bdev, -1, (caddr_t)&q_off);
 265                                 } else {
 266                                         ret = 0;
 267                                 }
 268 #else
 269                                 ret = -1;
 270 #endif
 271                         }
 272
 273                         break;
 274 #ifdef HAVE_GROUP_QUOTA
 275                 case SMB_GROUP_FS_QUOTA_TYPE:
 276                         DEBUG(10,("sys_set_xfs_quota: path[%s] bdev[%s] SMB_GROUP_FS_QUOTA_TYPE (gid[%u])\n",
 277                                 path, bdev, (unsigned)id.gid));
 278
 279                         quotactl(QCMD(Q_XGETQSTAT,GRPQUOTA), bdev, -1, (caddr_t)&F);
 280
 281                         if (qflags & QUOTAS_DENY_DISK) {
 282                                 if (!(F.qs_flags & XFS_QUOTA_GDQ_ENFD))
 283                                         q_on |= XFS_QUOTA_GDQ_ENFD;
 284                                 if (!(F.qs_flags & XFS_QUOTA_GDQ_ACCT))
 285                                         q_on |= XFS_QUOTA_GDQ_ACCT;
 286
 287                                 if (q_on != 0) {
 288                                         ret = quotactl(QCMD(Q_XQUOTAON,GRPQUOTA),bdev, -1, (caddr_t)&q_on);
 289                                 } else {
 290                                         ret = 0;
 291                                 }
 292
 293                         } else if (qflags & QUOTAS_ENABLED) {
 294                                 if (F.qs_flags & XFS_QUOTA_GDQ_ENFD)
 295                                         q_off |= XFS_QUOTA_GDQ_ENFD;
 296
 297                                 if (q_off != 0) {
 298                                         ret = quotactl(QCMD(Q_XQUOTAOFF,GRPQUOTA),bdev, -1, (caddr_t)&q_off);
 299                                 } else {
 300                                         ret = 0;
 301                                 }
 302
 303                                 if (!(F.qs_flags & XFS_QUOTA_GDQ_ACCT))
 304                                         q_on |= XFS_QUOTA_GDQ_ACCT;
 305
 306                                 if (q_on != 0) {
 307                                         ret = quotactl(QCMD(Q_XQUOTAON,GRPQUOTA),bdev, -1, (caddr_t)&q_on);
 308                                 } else {
 309                                         ret = 0;
 310                                 }
 311                         } else {
 312 #if 0
 313                         /* Switch on XFS_QUOTA_UDQ_ACCT didn't work!
 314                          * only swittching off XFS_QUOTA_UDQ_ACCT work
 315                          */
 316                                 if (F.qs_flags & XFS_QUOTA_GDQ_ENFD)
 317                                         q_off |= XFS_QUOTA_GDQ_ENFD;
 318                                 if (F.qs_flags & XFS_QUOTA_GDQ_ACCT)
 319                                         q_off |= XFS_QUOTA_GDQ_ACCT;
 320
 321                                 if (q_off !=0) {
 322                                         ret = quotactl(QCMD(Q_XQUOTAOFF,GRPQUOTA),bdev, -1, (caddr_t)&q_off);
 323                                 } else {
 324                                         ret = 0;
 325                                 }
 326 #else
 327                                 ret = -1;
 328 #endif
 329                         }
 330
 331                         break;
 332 #endif /* HAVE_GROUP_QUOTA */
 333                 default:
 334                         errno = ENOSYS;
 335                         return -1;
 336         }
 337
 338         return ret;
 339 }
 340
 341 #else /* HAVE_XFS_QUOTAS */
 342  void dummy_sysquotas_xfs(void);
 343
 344  void dummy_sysquotas_xfs(void){}
 345 #endif /* HAVE_XFS_QUOTAS */