cmd/zfs/zfs_project.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright (c) 2017, Intle Corporation. All rights reserved.
  24  */
  25
  26 #include <errno.h>
  27 #include <getopt.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <strings.h>
  31 #include <unistd.h>
  32 #include <fcntl.h>
  33 #include <dirent.h>
  34 #include <stddef.h>
  35 #include <libintl.h>
  36 #include <sys/stat.h>
  37 #include <sys/types.h>
  38 #include <sys/list.h>
  39 #include <sys/zfs_project.h>
  40
  41 #include "zfs_util.h"
  42 #include "zfs_projectutil.h"
  43
  44 typedef struct zfs_project_item {
  45         list_node_t     zpi_list;
  46         char            zpi_name[PATH_MAX];
  47 } zfs_project_item_t;
  48
  49 static void
  50 zfs_project_item_alloc(list_t *head, const char *name)
  51 {
  52         zfs_project_item_t *zpi;
  53
  54         zpi = safe_malloc(sizeof (zfs_project_item_t));
  55         strcpy(zpi->zpi_name, name);
  56         list_insert_tail(head, zpi);
  57 }
  58
  59 static int
  60 zfs_project_sanity_check(const char *name, zfs_project_control_t *zpc,
  61     struct stat *st)
  62 {
  63         int ret;
  64
  65         ret = stat(name, st);
  66         if (ret) {
  67                 (void) fprintf(stderr, gettext("failed to stat %s: %s\n"),
  68                     name, strerror(errno));
  69                 return (ret);
  70         }
  71
  72         if (!S_ISREG(st->st_mode) && !S_ISDIR(st->st_mode)) {
  73                 (void) fprintf(stderr, gettext("only support project quota on "
  74                     "regular file or directory\n"));
  75                 return (-1);
  76         }
  77
  78         if (!S_ISDIR(st->st_mode)) {
  79                 if (zpc->zpc_dironly) {
  80                         (void) fprintf(stderr, gettext(
  81                             "'-d' option on non-dir target %s\n"), name);
  82                         return (-1);
  83                 }
  84
  85                 if (zpc->zpc_recursive) {
  86                         (void) fprintf(stderr, gettext(
  87                             "'-r' option on non-dir target %s\n"), name);
  88                         return (-1);
  89                 }
  90         }
  91
  92         return (0);
  93 }
  94
  95 static int
  96 zfs_project_load_projid(const char *name, zfs_project_control_t *zpc)
  97 {
  98         zfsxattr_t fsx;
  99         int ret, fd;
 100
 101         fd = open(name, O_RDONLY | O_NOCTTY);
 102         if (fd < 0) {
 103                 (void) fprintf(stderr, gettext("failed to open %s: %s\n"),
 104                     name, strerror(errno));
 105                 return (fd);
 106         }
 107
 108         ret = ioctl(fd, ZFS_IOC_FSGETXATTR, &fsx);
 109         if (ret)
 110                 (void) fprintf(stderr,
 111                     gettext("failed to get xattr for %s: %s\n"),
 112                     name, strerror(errno));
 113         else
 114                 zpc->zpc_expected_projid = fsx.fsx_projid;
 115
 116         close(fd);
 117         return (ret);
 118 }
 119
 120 static int
 121 zfs_project_handle_one(const char *name, zfs_project_control_t *zpc)
 122 {
 123         zfsxattr_t fsx;
 124         int ret, fd;
 125
 126         fd = open(name, O_RDONLY | O_NOCTTY);
 127         if (fd < 0) {
 128                 if (errno == ENOENT && zpc->zpc_ignore_noent)
 129                         return (0);
 130
 131                 (void) fprintf(stderr, gettext("failed to open %s: %s\n"),
 132                     name, strerror(errno));
 133                 return (fd);
 134         }
 135
 136         ret = ioctl(fd, ZFS_IOC_FSGETXATTR, &fsx);
 137         if (ret) {
 138                 (void) fprintf(stderr,
 139                     gettext("failed to get xattr for %s: %s\n"),
 140                     name, strerror(errno));
 141                 goto out;
 142         }
 143
 144         switch (zpc->zpc_op) {
 145         case ZFS_PROJECT_OP_LIST:
 146                 (void) printf("%5u %c %s\n", fsx.fsx_projid,
 147                     (fsx.fsx_xflags & ZFS_PROJINHERIT_FL) ? 'P' : '-', name);
 148                 goto out;
 149         case ZFS_PROJECT_OP_CHECK:
 150                 if (fsx.fsx_projid == zpc->zpc_expected_projid &&
 151                     fsx.fsx_xflags & ZFS_PROJINHERIT_FL)
 152                         goto out;
 153
 154                 if (!zpc->zpc_newline) {
 155                         char c = '\0';
 156
 157                         (void) printf("%s%c", name, c);
 158                         goto out;
 159                 }
 160
 161                 if (fsx.fsx_projid != zpc->zpc_expected_projid)
 162                         (void) printf("%s - project ID is not set properly "
 163                             "(%u/%u)\n", name, fsx.fsx_projid,
 164                             (uint32_t)zpc->zpc_expected_projid);
 165
 166                 if (!(fsx.fsx_xflags & ZFS_PROJINHERIT_FL))
 167                         (void) printf("%s - project inherit flag is not set\n",
 168                             name);
 169
 170                 goto out;
 171         case ZFS_PROJECT_OP_CLEAR:
 172                 if (!(fsx.fsx_xflags & ZFS_PROJINHERIT_FL) &&
 173                     (zpc->zpc_keep_projid ||
 174                     fsx.fsx_projid == ZFS_DEFAULT_PROJID))
 175                         goto out;
 176
 177                 fsx.fsx_xflags &= ~ZFS_PROJINHERIT_FL;
 178                 if (!zpc->zpc_keep_projid)
 179                         fsx.fsx_projid = ZFS_DEFAULT_PROJID;
 180                 break;
 181         case ZFS_PROJECT_OP_SET:
 182                 if (fsx.fsx_projid == zpc->zpc_expected_projid &&
 183                     (!zpc->zpc_set_flag || fsx.fsx_xflags & ZFS_PROJINHERIT_FL))
 184                         goto out;
 185
 186                 fsx.fsx_projid = zpc->zpc_expected_projid;
 187                 if (zpc->zpc_set_flag)
 188                         fsx.fsx_xflags |= ZFS_PROJINHERIT_FL;
 189                 break;
 190         default:
 191                 ASSERT(0);
 192                 break;
 193         }
 194
 195         ret = ioctl(fd, ZFS_IOC_FSSETXATTR, &fsx);
 196         if (ret)
 197                 (void) fprintf(stderr,
 198                     gettext("failed to set xattr for %s: %s\n"),
 199                     name, strerror(errno));
 200
 201 out:
 202         close(fd);
 203         return (ret);
 204 }
 205
 206 static int
 207 zfs_project_handle_dir(const char *name, zfs_project_control_t *zpc,
 208     list_t *head)
 209 {
 210         char fullname[PATH_MAX];
 211         struct dirent *ent;
 212         DIR *dir;
 213         int ret = 0;
 214
 215         dir = opendir(name);
 216         if (dir == NULL) {
 217                 if (errno == ENOENT && zpc->zpc_ignore_noent)
 218                         return (0);
 219
 220                 ret = -errno;
 221                 (void) fprintf(stderr, gettext("failed to opendir %s: %s\n"),
 222                     name, strerror(errno));
 223                 return (ret);
 224         }
 225
 226         /* Non-top item, ignore the case of being removed or renamed by race. */
 227         zpc->zpc_ignore_noent = B_TRUE;
 228         errno = 0;
 229         while (!ret && (ent = readdir(dir)) != NULL) {
 230                 /* skip "." and ".." */
 231                 if (strcmp(ent->d_name, ".") == 0 ||
 232                     strcmp(ent->d_name, "..") == 0)
 233                         continue;
 234
 235                 if (strlen(ent->d_name) + strlen(name) >=
 236                     sizeof (fullname) + 1) {
 237                         errno = ENAMETOOLONG;
 238                         break;
 239                 }
 240
 241                 sprintf(fullname, "%s/%s", name, ent->d_name);
 242                 ret = zfs_project_handle_one(fullname, zpc);
 243                 if (!ret && zpc->zpc_recursive && ent->d_type == DT_DIR)
 244                         zfs_project_item_alloc(head, fullname);
 245         }
 246
 247         if (errno && !ret) {
 248                 ret = -errno;
 249                 (void) fprintf(stderr, gettext("failed to readdir %s: %s\n"),
 250                     name, strerror(errno));
 251         }
 252
 253         closedir(dir);
 254         return (ret);
 255 }
 256
 257 int
 258 zfs_project_handle(const char *name, zfs_project_control_t *zpc)
 259 {
 260         zfs_project_item_t *zpi;
 261         struct stat st;
 262         list_t head;
 263         int ret;
 264
 265         ret = zfs_project_sanity_check(name, zpc, &st);
 266         if (ret)
 267                 return (ret);
 268
 269         if ((zpc->zpc_op == ZFS_PROJECT_OP_SET ||
 270             zpc->zpc_op == ZFS_PROJECT_OP_CHECK) &&
 271             zpc->zpc_expected_projid == ZFS_INVALID_PROJID) {
 272                 ret = zfs_project_load_projid(name, zpc);
 273                 if (ret)
 274                         return (ret);
 275         }
 276
 277         zpc->zpc_ignore_noent = B_FALSE;
 278         ret = zfs_project_handle_one(name, zpc);
 279         if (ret || !S_ISDIR(st.st_mode) || zpc->zpc_dironly ||
 280             (!zpc->zpc_recursive &&
 281             zpc->zpc_op != ZFS_PROJECT_OP_LIST &&
 282             zpc->zpc_op != ZFS_PROJECT_OP_CHECK))
 283                 return (ret);
 284
 285         list_create(&head, sizeof (zfs_project_item_t),
 286             offsetof(zfs_project_item_t, zpi_list));
 287         zfs_project_item_alloc(&head, name);
 288         while ((zpi = list_remove_head(&head)) != NULL) {
 289                 if (!ret)
 290                         ret = zfs_project_handle_dir(zpi->zpi_name, zpc, &head);
 291                 free(zpi);
 292         }
 293
 294         return (ret);
 295 }