]> granicus.if.org Git - zfs/blob - module/zfs/zvol.c
Illumos #3236
[zfs] / module / zfs / zvol.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  * Copyright (C) 2008-2010 Lawrence Livermore National Security, LLC.
23  * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
24  * Rewritten for Linux by Brian Behlendorf <behlendorf1@llnl.gov>.
25  * LLNL-CODE-403049.
26  *
27  * ZFS volume emulation driver.
28  *
29  * Makes a DMU object look like a volume of arbitrary size, up to 2^64 bytes.
30  * Volumes are accessed through the symbolic links named:
31  *
32  * /dev/<pool_name>/<dataset_name>
33  *
34  * Volumes are persistent through reboot and module load.  No user command
35  * needs to be run before opening and using a device.
36  */
37
38 #include <sys/dbuf.h>
39 #include <sys/dmu_traverse.h>
40 #include <sys/dsl_dataset.h>
41 #include <sys/dsl_prop.h>
42 #include <sys/zap.h>
43 #include <sys/zil_impl.h>
44 #include <sys/zio.h>
45 #include <sys/zfs_rlock.h>
46 #include <sys/zfs_znode.h>
47 #include <sys/zvol.h>
48 #include <linux/blkdev_compat.h>
49
50 unsigned int zvol_inhibit_dev = 0;
51 unsigned int zvol_major = ZVOL_MAJOR;
52 unsigned int zvol_threads = 32;
53 unsigned long zvol_max_discard_blocks = 16384;
54
55 static taskq_t *zvol_taskq;
56 static kmutex_t zvol_state_lock;
57 static list_t zvol_state_list;
58 static char *zvol_tag = "zvol_tag";
59
60 /*
61  * The in-core state of each volume.
62  */
63 typedef struct zvol_state {
64         char                    zv_name[MAXNAMELEN];    /* name */
65         uint64_t                zv_volsize;     /* advertised space */
66         uint64_t                zv_volblocksize;/* volume block size */
67         objset_t                *zv_objset;     /* objset handle */
68         uint32_t                zv_flags;       /* ZVOL_* flags */
69         uint32_t                zv_open_count;  /* open counts */
70         uint32_t                zv_changed;     /* disk changed */
71         zilog_t                 *zv_zilog;      /* ZIL handle */
72         znode_t                 zv_znode;       /* for range locking */
73         dmu_buf_t               *zv_dbuf;       /* bonus handle */
74         dev_t                   zv_dev;         /* device id */
75         struct gendisk          *zv_disk;       /* generic disk */
76         struct request_queue    *zv_queue;      /* request queue */
77         spinlock_t              zv_lock;        /* request queue lock */
78         list_node_t             zv_next;        /* next zvol_state_t linkage */
79 } zvol_state_t;
80
81 #define ZVOL_RDONLY     0x1
82
83 /*
84  * Find the next available range of ZVOL_MINORS minor numbers.  The
85  * zvol_state_list is kept in ascending minor order so we simply need
86  * to scan the list for the first gap in the sequence.  This allows us
87  * to recycle minor number as devices are created and removed.
88  */
89 static int
90 zvol_find_minor(unsigned *minor)
91 {
92         zvol_state_t *zv;
93
94         *minor = 0;
95         ASSERT(MUTEX_HELD(&zvol_state_lock));
96         for (zv = list_head(&zvol_state_list); zv != NULL;
97              zv = list_next(&zvol_state_list, zv), *minor += ZVOL_MINORS) {
98                 if (MINOR(zv->zv_dev) != MINOR(*minor))
99                         break;
100         }
101
102         /* All minors are in use */
103         if (*minor >= (1 << MINORBITS))
104                 return ENXIO;
105
106         return 0;
107 }
108
109 /*
110  * Find a zvol_state_t given the full major+minor dev_t.
111  */
112 static zvol_state_t *
113 zvol_find_by_dev(dev_t dev)
114 {
115         zvol_state_t *zv;
116
117         ASSERT(MUTEX_HELD(&zvol_state_lock));
118         for (zv = list_head(&zvol_state_list); zv != NULL;
119              zv = list_next(&zvol_state_list, zv)) {
120                 if (zv->zv_dev == dev)
121                         return zv;
122         }
123
124         return NULL;
125 }
126
127 /*
128  * Find a zvol_state_t given the name provided at zvol_alloc() time.
129  */
130 static zvol_state_t *
131 zvol_find_by_name(const char *name)
132 {
133         zvol_state_t *zv;
134
135         ASSERT(MUTEX_HELD(&zvol_state_lock));
136         for (zv = list_head(&zvol_state_list); zv != NULL;
137              zv = list_next(&zvol_state_list, zv)) {
138                 if (!strncmp(zv->zv_name, name, MAXNAMELEN))
139                         return zv;
140         }
141
142         return NULL;
143 }
144
145
146 /*
147  * Given a path, return TRUE if path is a ZVOL.
148  */
149 boolean_t
150 zvol_is_zvol(const char *device)
151 {
152         struct block_device *bdev;
153         unsigned int major;
154
155         bdev = lookup_bdev(device);
156         if (IS_ERR(bdev))
157                 return (B_FALSE);
158
159         major = MAJOR(bdev->bd_dev);
160         bdput(bdev);
161
162         if (major == zvol_major)
163             return (B_TRUE);
164
165         return (B_FALSE);
166 }
167
168 /*
169  * ZFS_IOC_CREATE callback handles dmu zvol and zap object creation.
170  */
171 void
172 zvol_create_cb(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx)
173 {
174         zfs_creat_t *zct = arg;
175         nvlist_t *nvprops = zct->zct_props;
176         int error;
177         uint64_t volblocksize, volsize;
178
179         VERIFY(nvlist_lookup_uint64(nvprops,
180             zfs_prop_to_name(ZFS_PROP_VOLSIZE), &volsize) == 0);
181         if (nvlist_lookup_uint64(nvprops,
182             zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE), &volblocksize) != 0)
183                 volblocksize = zfs_prop_default_numeric(ZFS_PROP_VOLBLOCKSIZE);
184
185         /*
186          * These properties must be removed from the list so the generic
187          * property setting step won't apply to them.
188          */
189         VERIFY(nvlist_remove_all(nvprops,
190             zfs_prop_to_name(ZFS_PROP_VOLSIZE)) == 0);
191         (void) nvlist_remove_all(nvprops,
192             zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE));
193
194         error = dmu_object_claim(os, ZVOL_OBJ, DMU_OT_ZVOL, volblocksize,
195             DMU_OT_NONE, 0, tx);
196         ASSERT(error == 0);
197
198         error = zap_create_claim(os, ZVOL_ZAP_OBJ, DMU_OT_ZVOL_PROP,
199             DMU_OT_NONE, 0, tx);
200         ASSERT(error == 0);
201
202         error = zap_update(os, ZVOL_ZAP_OBJ, "size", 8, 1, &volsize, tx);
203         ASSERT(error == 0);
204 }
205
206 /*
207  * ZFS_IOC_OBJSET_STATS entry point.
208  */
209 int
210 zvol_get_stats(objset_t *os, nvlist_t *nv)
211 {
212         int error;
213         dmu_object_info_t *doi;
214         uint64_t val;
215
216         error = zap_lookup(os, ZVOL_ZAP_OBJ, "size", 8, 1, &val);
217         if (error)
218                 return (error);
219
220         dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_VOLSIZE, val);
221         doi = kmem_alloc(sizeof(dmu_object_info_t), KM_SLEEP);
222         error = dmu_object_info(os, ZVOL_OBJ, doi);
223
224         if (error == 0) {
225                 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_VOLBLOCKSIZE,
226                     doi->doi_data_block_size);
227         }
228
229         kmem_free(doi, sizeof(dmu_object_info_t));
230
231         return (error);
232 }
233
234 /*
235  * Sanity check volume size.
236  */
237 int
238 zvol_check_volsize(uint64_t volsize, uint64_t blocksize)
239 {
240         if (volsize == 0)
241                 return (SET_ERROR(EINVAL));
242
243         if (volsize % blocksize != 0)
244                 return (SET_ERROR(EINVAL));
245
246 #ifdef _ILP32
247         if (volsize - 1 > MAXOFFSET_T)
248                 return (SET_ERROR(EOVERFLOW));
249 #endif
250         return (0);
251 }
252
253 /*
254  * Ensure the zap is flushed then inform the VFS of the capacity change.
255  */
256 static int
257 zvol_update_volsize(zvol_state_t *zv, uint64_t volsize, objset_t *os)
258 {
259         struct block_device *bdev;
260         dmu_tx_t *tx;
261         int error;
262
263         ASSERT(MUTEX_HELD(&zvol_state_lock));
264
265         tx = dmu_tx_create(os);
266         dmu_tx_hold_zap(tx, ZVOL_ZAP_OBJ, TRUE, NULL);
267         error = dmu_tx_assign(tx, TXG_WAIT);
268         if (error) {
269                 dmu_tx_abort(tx);
270                 return (error);
271         }
272
273         error = zap_update(os, ZVOL_ZAP_OBJ, "size", 8, 1,
274             &volsize, tx);
275         dmu_tx_commit(tx);
276
277         if (error)
278                 return (error);
279
280         error = dmu_free_long_range(os,
281             ZVOL_OBJ, volsize, DMU_OBJECT_END);
282         if (error)
283                 return (error);
284
285         bdev = bdget_disk(zv->zv_disk, 0);
286         if (!bdev)
287                 return (SET_ERROR(EIO));
288 /*
289  * 2.6.28 API change
290  * Added check_disk_size_change() helper function.
291  */
292 #ifdef HAVE_CHECK_DISK_SIZE_CHANGE
293         set_capacity(zv->zv_disk, volsize >> 9);
294         zv->zv_volsize = volsize;
295         check_disk_size_change(zv->zv_disk, bdev);
296 #else
297         zv->zv_volsize = volsize;
298         zv->zv_changed = 1;
299         (void) check_disk_change(bdev);
300 #endif /* HAVE_CHECK_DISK_SIZE_CHANGE */
301
302         bdput(bdev);
303
304         return (0);
305 }
306
307 /*
308  * Set ZFS_PROP_VOLSIZE set entry point.
309  */
310 int
311 zvol_set_volsize(const char *name, uint64_t volsize)
312 {
313         zvol_state_t *zv;
314         dmu_object_info_t *doi;
315         objset_t *os = NULL;
316         uint64_t readonly;
317         int error;
318
319         error = dsl_prop_get_integer(name,
320             zfs_prop_to_name(ZFS_PROP_READONLY), &readonly, NULL);
321         if (error != 0)
322                 return (error);
323         if (readonly)
324                 return (SET_ERROR(EROFS));
325
326         mutex_enter(&zvol_state_lock);
327
328         zv = zvol_find_by_name(name);
329         if (zv == NULL) {
330                 error = SET_ERROR(ENXIO);
331                 goto out;
332         }
333
334         doi = kmem_alloc(sizeof(dmu_object_info_t), KM_SLEEP);
335
336         error = dmu_objset_hold(name, FTAG, &os);
337         if (error)
338                 goto out_doi;
339
340         if ((error = dmu_object_info(os, ZVOL_OBJ, doi)) != 0 ||
341             (error = zvol_check_volsize(volsize,doi->doi_data_block_size)) != 0)
342                 goto out_doi;
343
344         VERIFY(dsl_prop_get_integer(name, "readonly", &readonly, NULL) == 0);
345         if (readonly) {
346                 error = SET_ERROR(EROFS);
347                 goto out_doi;
348         }
349
350         if (get_disk_ro(zv->zv_disk) || (zv->zv_flags & ZVOL_RDONLY)) {
351                 error = SET_ERROR(EROFS);
352                 goto out_doi;
353         }
354
355         error = zvol_update_volsize(zv, volsize, os);
356 out_doi:
357         kmem_free(doi, sizeof(dmu_object_info_t));
358 out:
359         if (os)
360                 dmu_objset_rele(os, FTAG);
361
362         mutex_exit(&zvol_state_lock);
363
364         return (error);
365 }
366
367 /*
368  * Sanity check volume block size.
369  */
370 int
371 zvol_check_volblocksize(uint64_t volblocksize)
372 {
373         if (volblocksize < SPA_MINBLOCKSIZE ||
374             volblocksize > SPA_MAXBLOCKSIZE ||
375             !ISP2(volblocksize))
376                 return (SET_ERROR(EDOM));
377
378         return (0);
379 }
380
381 /*
382  * Set ZFS_PROP_VOLBLOCKSIZE set entry point.
383  */
384 int
385 zvol_set_volblocksize(const char *name, uint64_t volblocksize)
386 {
387         zvol_state_t *zv;
388         dmu_tx_t *tx;
389         int error;
390
391         mutex_enter(&zvol_state_lock);
392
393         zv = zvol_find_by_name(name);
394         if (zv == NULL) {
395                 error = SET_ERROR(ENXIO);
396                 goto out;
397         }
398
399         if (get_disk_ro(zv->zv_disk) || (zv->zv_flags & ZVOL_RDONLY)) {
400                 error = SET_ERROR(EROFS);
401                 goto out;
402         }
403
404         tx = dmu_tx_create(zv->zv_objset);
405         dmu_tx_hold_bonus(tx, ZVOL_OBJ);
406         error = dmu_tx_assign(tx, TXG_WAIT);
407         if (error) {
408                 dmu_tx_abort(tx);
409         } else {
410                 error = dmu_object_set_blocksize(zv->zv_objset, ZVOL_OBJ,
411                     volblocksize, 0, tx);
412                 if (error == ENOTSUP)
413                         error = SET_ERROR(EBUSY);
414                 dmu_tx_commit(tx);
415                 if (error == 0)
416                         zv->zv_volblocksize = volblocksize;
417         }
418 out:
419         mutex_exit(&zvol_state_lock);
420
421         return (error);
422 }
423
424 /*
425  * Replay a TX_WRITE ZIL transaction that didn't get committed
426  * after a system failure
427  */
428 static int
429 zvol_replay_write(zvol_state_t *zv, lr_write_t *lr, boolean_t byteswap)
430 {
431         objset_t *os = zv->zv_objset;
432         char *data = (char *)(lr + 1);  /* data follows lr_write_t */
433         uint64_t off = lr->lr_offset;
434         uint64_t len = lr->lr_length;
435         dmu_tx_t *tx;
436         int error;
437
438         if (byteswap)
439                 byteswap_uint64_array(lr, sizeof (*lr));
440
441         tx = dmu_tx_create(os);
442         dmu_tx_hold_write(tx, ZVOL_OBJ, off, len);
443         error = dmu_tx_assign(tx, TXG_WAIT);
444         if (error) {
445                 dmu_tx_abort(tx);
446         } else {
447                 dmu_write(os, ZVOL_OBJ, off, len, data, tx);
448                 dmu_tx_commit(tx);
449         }
450
451         return (error);
452 }
453
454 static int
455 zvol_replay_err(zvol_state_t *zv, lr_t *lr, boolean_t byteswap)
456 {
457         return (SET_ERROR(ENOTSUP));
458 }
459
460 /*
461  * Callback vectors for replaying records.
462  * Only TX_WRITE is needed for zvol.
463  */
464 zil_replay_func_t zvol_replay_vector[TX_MAX_TYPE] = {
465         (zil_replay_func_t)zvol_replay_err,     /* no such transaction type */
466         (zil_replay_func_t)zvol_replay_err,     /* TX_CREATE */
467         (zil_replay_func_t)zvol_replay_err,     /* TX_MKDIR */
468         (zil_replay_func_t)zvol_replay_err,     /* TX_MKXATTR */
469         (zil_replay_func_t)zvol_replay_err,     /* TX_SYMLINK */
470         (zil_replay_func_t)zvol_replay_err,     /* TX_REMOVE */
471         (zil_replay_func_t)zvol_replay_err,     /* TX_RMDIR */
472         (zil_replay_func_t)zvol_replay_err,     /* TX_LINK */
473         (zil_replay_func_t)zvol_replay_err,     /* TX_RENAME */
474         (zil_replay_func_t)zvol_replay_write,   /* TX_WRITE */
475         (zil_replay_func_t)zvol_replay_err,     /* TX_TRUNCATE */
476         (zil_replay_func_t)zvol_replay_err,     /* TX_SETATTR */
477         (zil_replay_func_t)zvol_replay_err,     /* TX_ACL */
478 };
479
480 /*
481  * zvol_log_write() handles synchronous writes using TX_WRITE ZIL transactions.
482  *
483  * We store data in the log buffers if it's small enough.
484  * Otherwise we will later flush the data out via dmu_sync().
485  */
486 ssize_t zvol_immediate_write_sz = 32768;
487
488 static void
489 zvol_log_write(zvol_state_t *zv, dmu_tx_t *tx,
490                uint64_t offset, uint64_t size, int sync)
491 {
492         uint32_t blocksize = zv->zv_volblocksize;
493         zilog_t *zilog = zv->zv_zilog;
494         boolean_t slogging;
495         ssize_t immediate_write_sz;
496
497         if (zil_replaying(zilog, tx))
498                 return;
499
500         immediate_write_sz = (zilog->zl_logbias == ZFS_LOGBIAS_THROUGHPUT)
501                 ? 0 : zvol_immediate_write_sz;
502         slogging = spa_has_slogs(zilog->zl_spa) &&
503                 (zilog->zl_logbias == ZFS_LOGBIAS_LATENCY);
504
505         while (size) {
506                 itx_t *itx;
507                 lr_write_t *lr;
508                 ssize_t len;
509                 itx_wr_state_t write_state;
510
511                 /*
512                  * Unlike zfs_log_write() we can be called with
513                  * up to DMU_MAX_ACCESS/2 (5MB) writes.
514                  */
515                 if (blocksize > immediate_write_sz && !slogging &&
516                     size >= blocksize && offset % blocksize == 0) {
517                         write_state = WR_INDIRECT; /* uses dmu_sync */
518                         len = blocksize;
519                 } else if (sync) {
520                         write_state = WR_COPIED;
521                         len = MIN(ZIL_MAX_LOG_DATA, size);
522                 } else {
523                         write_state = WR_NEED_COPY;
524                         len = MIN(ZIL_MAX_LOG_DATA, size);
525                 }
526
527                 itx = zil_itx_create(TX_WRITE, sizeof (*lr) +
528                     (write_state == WR_COPIED ? len : 0));
529                 lr = (lr_write_t *)&itx->itx_lr;
530                 if (write_state == WR_COPIED && dmu_read(zv->zv_objset,
531                     ZVOL_OBJ, offset, len, lr+1, DMU_READ_NO_PREFETCH) != 0) {
532                         zil_itx_destroy(itx);
533                         itx = zil_itx_create(TX_WRITE, sizeof (*lr));
534                         lr = (lr_write_t *)&itx->itx_lr;
535                         write_state = WR_NEED_COPY;
536                 }
537
538                 itx->itx_wr_state = write_state;
539                 if (write_state == WR_NEED_COPY)
540                         itx->itx_sod += len;
541                 lr->lr_foid = ZVOL_OBJ;
542                 lr->lr_offset = offset;
543                 lr->lr_length = len;
544                 lr->lr_blkoff = 0;
545                 BP_ZERO(&lr->lr_blkptr);
546
547                 itx->itx_private = zv;
548                 itx->itx_sync = sync;
549
550                 (void) zil_itx_assign(zilog, itx, tx);
551
552                 offset += len;
553                 size -= len;
554         }
555 }
556
557 /*
558  * Common write path running under the zvol taskq context.  This function
559  * is responsible for copying the request structure data in to the DMU and
560  * signaling the request queue with the result of the copy.
561  */
562 static void
563 zvol_write(void *arg)
564 {
565         struct request *req = (struct request *)arg;
566         struct request_queue *q = req->q;
567         zvol_state_t *zv = q->queuedata;
568         uint64_t offset = blk_rq_pos(req) << 9;
569         uint64_t size = blk_rq_bytes(req);
570         int error = 0;
571         dmu_tx_t *tx;
572         rl_t *rl;
573
574         /*
575          * Annotate this call path with a flag that indicates that it is
576          * unsafe to use KM_SLEEP during memory allocations due to the
577          * potential for a deadlock.  KM_PUSHPAGE should be used instead.
578          */
579         ASSERT(!(current->flags & PF_NOFS));
580         current->flags |= PF_NOFS;
581
582         if (req->cmd_flags & VDEV_REQ_FLUSH)
583                 zil_commit(zv->zv_zilog, ZVOL_OBJ);
584
585         /*
586          * Some requests are just for flush and nothing else.
587          */
588         if (size == 0) {
589                 blk_end_request(req, 0, size);
590                 goto out;
591         }
592
593         rl = zfs_range_lock(&zv->zv_znode, offset, size, RL_WRITER);
594
595         tx = dmu_tx_create(zv->zv_objset);
596         dmu_tx_hold_write(tx, ZVOL_OBJ, offset, size);
597
598         /* This will only fail for ENOSPC */
599         error = dmu_tx_assign(tx, TXG_WAIT);
600         if (error) {
601                 dmu_tx_abort(tx);
602                 zfs_range_unlock(rl);
603                 blk_end_request(req, -error, size);
604                 goto out;
605         }
606
607         error = dmu_write_req(zv->zv_objset, ZVOL_OBJ, req, tx);
608         if (error == 0)
609                 zvol_log_write(zv, tx, offset, size,
610                     req->cmd_flags & VDEV_REQ_FUA);
611
612         dmu_tx_commit(tx);
613         zfs_range_unlock(rl);
614
615         if ((req->cmd_flags & VDEV_REQ_FUA) ||
616             zv->zv_objset->os_sync == ZFS_SYNC_ALWAYS)
617                 zil_commit(zv->zv_zilog, ZVOL_OBJ);
618
619         blk_end_request(req, -error, size);
620 out:
621         current->flags &= ~PF_NOFS;
622 }
623
624 #ifdef HAVE_BLK_QUEUE_DISCARD
625 static void
626 zvol_discard(void *arg)
627 {
628         struct request *req = (struct request *)arg;
629         struct request_queue *q = req->q;
630         zvol_state_t *zv = q->queuedata;
631         uint64_t start = blk_rq_pos(req) << 9;
632         uint64_t end = start + blk_rq_bytes(req);
633         int error;
634         rl_t *rl;
635
636         /*
637          * Annotate this call path with a flag that indicates that it is
638          * unsafe to use KM_SLEEP during memory allocations due to the
639          * potential for a deadlock.  KM_PUSHPAGE should be used instead.
640          */
641         ASSERT(!(current->flags & PF_NOFS));
642         current->flags |= PF_NOFS;
643
644         if (end > zv->zv_volsize) {
645                 blk_end_request(req, -EIO, blk_rq_bytes(req));
646                 goto out;
647         }
648
649         /*
650          * Align the request to volume block boundaries. If we don't,
651          * then this will force dnode_free_range() to zero out the
652          * unaligned parts, which is slow (read-modify-write) and
653          * useless since we are not freeing any space by doing so.
654          */
655         start = P2ROUNDUP(start, zv->zv_volblocksize);
656         end = P2ALIGN(end, zv->zv_volblocksize);
657
658         if (start >= end) {
659                 blk_end_request(req, 0, blk_rq_bytes(req));
660                 goto out;
661         }
662
663         rl = zfs_range_lock(&zv->zv_znode, start, end - start, RL_WRITER);
664
665         error = dmu_free_long_range(zv->zv_objset, ZVOL_OBJ, start, end - start);
666
667         /*
668          * TODO: maybe we should add the operation to the log.
669          */
670
671         zfs_range_unlock(rl);
672
673         blk_end_request(req, -error, blk_rq_bytes(req));
674 out:
675         current->flags &= ~PF_NOFS;
676 }
677 #endif /* HAVE_BLK_QUEUE_DISCARD */
678
679 /*
680  * Common read path running under the zvol taskq context.  This function
681  * is responsible for copying the requested data out of the DMU and in to
682  * a linux request structure.  It then must signal the request queue with
683  * an error code describing the result of the copy.
684  */
685 static void
686 zvol_read(void *arg)
687 {
688         struct request *req = (struct request *)arg;
689         struct request_queue *q = req->q;
690         zvol_state_t *zv = q->queuedata;
691         uint64_t offset = blk_rq_pos(req) << 9;
692         uint64_t size = blk_rq_bytes(req);
693         int error;
694         rl_t *rl;
695
696         if (size == 0) {
697                 blk_end_request(req, 0, size);
698                 return;
699         }
700
701         rl = zfs_range_lock(&zv->zv_znode, offset, size, RL_READER);
702
703         error = dmu_read_req(zv->zv_objset, ZVOL_OBJ, req);
704
705         zfs_range_unlock(rl);
706
707         /* convert checksum errors into IO errors */
708         if (error == ECKSUM)
709                 error = SET_ERROR(EIO);
710
711         blk_end_request(req, -error, size);
712 }
713
714 /*
715  * Request will be added back to the request queue and retried if
716  * it cannot be immediately dispatched to the taskq for handling
717  */
718 static inline void
719 zvol_dispatch(task_func_t func, struct request *req)
720 {
721         if (!taskq_dispatch(zvol_taskq, func, (void *)req, TQ_NOSLEEP))
722                 blk_requeue_request(req->q, req);
723 }
724
725 /*
726  * Common request path.  Rather than registering a custom make_request()
727  * function we use the generic Linux version.  This is done because it allows
728  * us to easily merge read requests which would otherwise we performed
729  * synchronously by the DMU.  This is less critical in write case where the
730  * DMU will perform the correct merging within a transaction group.  Using
731  * the generic make_request() also let's use leverage the fact that the
732  * elevator with ensure correct ordering in regards to barrior IOs.  On
733  * the downside it means that in the write case we end up doing request
734  * merging twice once in the elevator and once in the DMU.
735  *
736  * The request handler is called under a spin lock so all the real work
737  * is handed off to be done in the context of the zvol taskq.  This function
738  * simply performs basic request sanity checking and hands off the request.
739  */
740 static void
741 zvol_request(struct request_queue *q)
742 {
743         zvol_state_t *zv = q->queuedata;
744         struct request *req;
745         unsigned int size;
746
747         while ((req = blk_fetch_request(q)) != NULL) {
748                 size = blk_rq_bytes(req);
749
750                 if (size != 0 && blk_rq_pos(req) + blk_rq_sectors(req) >
751                     get_capacity(zv->zv_disk)) {
752                         printk(KERN_INFO
753                                "%s: bad access: block=%llu, count=%lu\n",
754                                req->rq_disk->disk_name,
755                                (long long unsigned)blk_rq_pos(req),
756                                (long unsigned)blk_rq_sectors(req));
757                         __blk_end_request(req, -EIO, size);
758                         continue;
759                 }
760
761                 if (!blk_fs_request(req)) {
762                         printk(KERN_INFO "%s: non-fs cmd\n",
763                                req->rq_disk->disk_name);
764                         __blk_end_request(req, -EIO, size);
765                         continue;
766                 }
767
768                 switch (rq_data_dir(req)) {
769                 case READ:
770                         zvol_dispatch(zvol_read, req);
771                         break;
772                 case WRITE:
773                         if (unlikely(get_disk_ro(zv->zv_disk)) ||
774                             unlikely(zv->zv_flags & ZVOL_RDONLY)) {
775                                 __blk_end_request(req, -EROFS, size);
776                                 break;
777                         }
778
779 #ifdef HAVE_BLK_QUEUE_DISCARD
780                         if (req->cmd_flags & VDEV_REQ_DISCARD) {
781                                 zvol_dispatch(zvol_discard, req);
782                                 break;
783                         }
784 #endif /* HAVE_BLK_QUEUE_DISCARD */
785
786                         zvol_dispatch(zvol_write, req);
787                         break;
788                 default:
789                         printk(KERN_INFO "%s: unknown cmd: %d\n",
790                                req->rq_disk->disk_name, (int)rq_data_dir(req));
791                         __blk_end_request(req, -EIO, size);
792                         break;
793                 }
794         }
795 }
796
797 static void
798 zvol_get_done(zgd_t *zgd, int error)
799 {
800         if (zgd->zgd_db)
801                 dmu_buf_rele(zgd->zgd_db, zgd);
802
803         zfs_range_unlock(zgd->zgd_rl);
804
805         if (error == 0 && zgd->zgd_bp)
806                 zil_add_block(zgd->zgd_zilog, zgd->zgd_bp);
807
808         kmem_free(zgd, sizeof (zgd_t));
809 }
810
811 /*
812  * Get data to generate a TX_WRITE intent log record.
813  */
814 static int
815 zvol_get_data(void *arg, lr_write_t *lr, char *buf, zio_t *zio)
816 {
817         zvol_state_t *zv = arg;
818         objset_t *os = zv->zv_objset;
819         uint64_t object = ZVOL_OBJ;
820         uint64_t offset = lr->lr_offset;
821         uint64_t size = lr->lr_length;
822         blkptr_t *bp = &lr->lr_blkptr;
823         dmu_buf_t *db;
824         zgd_t *zgd;
825         int error;
826
827         ASSERT(zio != NULL);
828         ASSERT(size != 0);
829
830         zgd = (zgd_t *)kmem_zalloc(sizeof (zgd_t), KM_PUSHPAGE);
831         zgd->zgd_zilog = zv->zv_zilog;
832         zgd->zgd_rl = zfs_range_lock(&zv->zv_znode, offset, size, RL_READER);
833
834         /*
835          * Write records come in two flavors: immediate and indirect.
836          * For small writes it's cheaper to store the data with the
837          * log record (immediate); for large writes it's cheaper to
838          * sync the data and get a pointer to it (indirect) so that
839          * we don't have to write the data twice.
840          */
841         if (buf != NULL) { /* immediate write */
842                 error = dmu_read(os, object, offset, size, buf,
843                     DMU_READ_NO_PREFETCH);
844         } else {
845                 size = zv->zv_volblocksize;
846                 offset = P2ALIGN_TYPED(offset, size, uint64_t);
847                 error = dmu_buf_hold(os, object, offset, zgd, &db,
848                     DMU_READ_NO_PREFETCH);
849                 if (error == 0) {
850                         blkptr_t *obp = dmu_buf_get_blkptr(db);
851                         if (obp) {
852                                 ASSERT(BP_IS_HOLE(bp));
853                                 *bp = *obp;
854                         }
855
856                         zgd->zgd_db = db;
857                         zgd->zgd_bp = &lr->lr_blkptr;
858
859                         ASSERT(db != NULL);
860                         ASSERT(db->db_offset == offset);
861                         ASSERT(db->db_size == size);
862
863                         error = dmu_sync(zio, lr->lr_common.lrc_txg,
864                             zvol_get_done, zgd);
865
866                         if (error == 0)
867                                 return (0);
868                 }
869         }
870
871         zvol_get_done(zgd, error);
872
873         return (error);
874 }
875
876 /*
877  * The zvol_state_t's are inserted in increasing MINOR(dev_t) order.
878  */
879 static void
880 zvol_insert(zvol_state_t *zv_insert)
881 {
882         zvol_state_t *zv = NULL;
883
884         ASSERT(MUTEX_HELD(&zvol_state_lock));
885         ASSERT3U(MINOR(zv_insert->zv_dev) & ZVOL_MINOR_MASK, ==, 0);
886         for (zv = list_head(&zvol_state_list); zv != NULL;
887              zv = list_next(&zvol_state_list, zv)) {
888                 if (MINOR(zv->zv_dev) > MINOR(zv_insert->zv_dev))
889                         break;
890         }
891
892         list_insert_before(&zvol_state_list, zv, zv_insert);
893 }
894
895 /*
896  * Simply remove the zvol from to list of zvols.
897  */
898 static void
899 zvol_remove(zvol_state_t *zv_remove)
900 {
901         ASSERT(MUTEX_HELD(&zvol_state_lock));
902         list_remove(&zvol_state_list, zv_remove);
903 }
904
905 static int
906 zvol_first_open(zvol_state_t *zv)
907 {
908         objset_t *os;
909         uint64_t volsize;
910         int locked = 0;
911         int error;
912         uint64_t ro;
913
914         /*
915          * In all other cases the spa_namespace_lock is taken before the
916          * bdev->bd_mutex lock.  But in this case the Linux __blkdev_get()
917          * function calls fops->open() with the bdev->bd_mutex lock held.
918          *
919          * To avoid a potential lock inversion deadlock we preemptively
920          * try to take the spa_namespace_lock().  Normally it will not
921          * be contended and this is safe because spa_open_common() handles
922          * the case where the caller already holds the spa_namespace_lock.
923          *
924          * When it is contended we risk a lock inversion if we were to
925          * block waiting for the lock.  Luckily, the __blkdev_get()
926          * function allows us to return -ERESTARTSYS which will result in
927          * bdev->bd_mutex being dropped, reacquired, and fops->open() being
928          * called again.  This process can be repeated safely until both
929          * locks are acquired.
930          */
931         if (!mutex_owned(&spa_namespace_lock)) {
932                 locked = mutex_tryenter(&spa_namespace_lock);
933                 if (!locked)
934                         return (-SET_ERROR(ERESTARTSYS));
935         }
936
937         /* lie and say we're read-only */
938         error = dmu_objset_own(zv->zv_name, DMU_OST_ZVOL, 1, zvol_tag, &os);
939         if (error)
940                 goto out_mutex;
941
942         error = zap_lookup(os, ZVOL_ZAP_OBJ, "size", 8, 1, &volsize);
943         if (error) {
944                 dmu_objset_disown(os, zvol_tag);
945                 goto out_mutex;
946         }
947
948         zv->zv_objset = os;
949         error = dmu_bonus_hold(os, ZVOL_OBJ, zvol_tag, &zv->zv_dbuf);
950         if (error) {
951                 dmu_objset_disown(os, zvol_tag);
952                 goto out_mutex;
953         }
954
955         set_capacity(zv->zv_disk, volsize >> 9);
956         zv->zv_volsize = volsize;
957         zv->zv_zilog = zil_open(os, zvol_get_data);
958
959         VERIFY(dsl_prop_get_integer(zv->zv_name, "readonly", &ro, NULL) == 0);
960         if (ro || dmu_objset_is_snapshot(os) ||
961             !spa_writeable(dmu_objset_spa(os))) {
962                 set_disk_ro(zv->zv_disk, 1);
963                 zv->zv_flags |= ZVOL_RDONLY;
964         } else {
965                 set_disk_ro(zv->zv_disk, 0);
966                 zv->zv_flags &= ~ZVOL_RDONLY;
967         }
968
969 out_mutex:
970         if (locked)
971                 mutex_exit(&spa_namespace_lock);
972
973         return (-error);
974 }
975
976 static void
977 zvol_last_close(zvol_state_t *zv)
978 {
979         zil_close(zv->zv_zilog);
980         zv->zv_zilog = NULL;
981
982         dmu_buf_rele(zv->zv_dbuf, zvol_tag);
983         zv->zv_dbuf = NULL;
984
985         /*
986          * Evict cached data
987          */
988         if (dsl_dataset_is_dirty(dmu_objset_ds(zv->zv_objset)) &&
989             !(zv->zv_flags & ZVOL_RDONLY))
990                 txg_wait_synced(dmu_objset_pool(zv->zv_objset), 0);
991         (void) dmu_objset_evict_dbufs(zv->zv_objset);
992
993         dmu_objset_disown(zv->zv_objset, zvol_tag);
994         zv->zv_objset = NULL;
995 }
996
997 static int
998 zvol_open(struct block_device *bdev, fmode_t flag)
999 {
1000         zvol_state_t *zv = bdev->bd_disk->private_data;
1001         int error = 0, drop_mutex = 0;
1002
1003         /*
1004          * If the caller is already holding the mutex do not take it
1005          * again, this will happen as part of zvol_create_minor().
1006          * Once add_disk() is called the device is live and the kernel
1007          * will attempt to open it to read the partition information.
1008          */
1009         if (!mutex_owned(&zvol_state_lock)) {
1010                 mutex_enter(&zvol_state_lock);
1011                 drop_mutex = 1;
1012         }
1013
1014         ASSERT3P(zv, !=, NULL);
1015
1016         if (zv->zv_open_count == 0) {
1017                 error = zvol_first_open(zv);
1018                 if (error)
1019                         goto out_mutex;
1020         }
1021
1022         if ((flag & FMODE_WRITE) &&
1023             (get_disk_ro(zv->zv_disk) || (zv->zv_flags & ZVOL_RDONLY))) {
1024                 error = -EROFS;
1025                 goto out_open_count;
1026         }
1027
1028         zv->zv_open_count++;
1029
1030 out_open_count:
1031         if (zv->zv_open_count == 0)
1032                 zvol_last_close(zv);
1033
1034 out_mutex:
1035         if (drop_mutex)
1036                 mutex_exit(&zvol_state_lock);
1037
1038         check_disk_change(bdev);
1039
1040         return (error);
1041 }
1042
1043 #ifdef HAVE_BLOCK_DEVICE_OPERATIONS_RELEASE_VOID
1044 static void
1045 #else
1046 static int
1047 #endif
1048 zvol_release(struct gendisk *disk, fmode_t mode)
1049 {
1050         zvol_state_t *zv = disk->private_data;
1051         int drop_mutex = 0;
1052
1053         if (!mutex_owned(&zvol_state_lock)) {
1054                 mutex_enter(&zvol_state_lock);
1055                 drop_mutex = 1;
1056         }
1057
1058         ASSERT3P(zv, !=, NULL);
1059         ASSERT3U(zv->zv_open_count, >, 0);
1060         zv->zv_open_count--;
1061         if (zv->zv_open_count == 0)
1062                 zvol_last_close(zv);
1063
1064         if (drop_mutex)
1065                 mutex_exit(&zvol_state_lock);
1066
1067 #ifndef HAVE_BLOCK_DEVICE_OPERATIONS_RELEASE_VOID
1068         return (0);
1069 #endif
1070 }
1071
1072 static int
1073 zvol_ioctl(struct block_device *bdev, fmode_t mode,
1074            unsigned int cmd, unsigned long arg)
1075 {
1076         zvol_state_t *zv = bdev->bd_disk->private_data;
1077         int error = 0;
1078
1079         if (zv == NULL)
1080                 return (-SET_ERROR(ENXIO));
1081
1082         switch (cmd) {
1083         case BLKFLSBUF:
1084                 zil_commit(zv->zv_zilog, ZVOL_OBJ);
1085                 break;
1086         case BLKZNAME:
1087                 error = copy_to_user((void *)arg, zv->zv_name, MAXNAMELEN);
1088                 break;
1089
1090         default:
1091                 error = -ENOTTY;
1092                 break;
1093
1094         }
1095
1096         return (error);
1097 }
1098
1099 #ifdef CONFIG_COMPAT
1100 static int
1101 zvol_compat_ioctl(struct block_device *bdev, fmode_t mode,
1102                   unsigned cmd, unsigned long arg)
1103 {
1104         return zvol_ioctl(bdev, mode, cmd, arg);
1105 }
1106 #else
1107 #define zvol_compat_ioctl   NULL
1108 #endif
1109
1110 static int zvol_media_changed(struct gendisk *disk)
1111 {
1112         zvol_state_t *zv = disk->private_data;
1113
1114         return zv->zv_changed;
1115 }
1116
1117 static int zvol_revalidate_disk(struct gendisk *disk)
1118 {
1119         zvol_state_t *zv = disk->private_data;
1120
1121         zv->zv_changed = 0;
1122         set_capacity(zv->zv_disk, zv->zv_volsize >> 9);
1123
1124         return 0;
1125 }
1126
1127 /*
1128  * Provide a simple virtual geometry for legacy compatibility.  For devices
1129  * smaller than 1 MiB a small head and sector count is used to allow very
1130  * tiny devices.  For devices over 1 Mib a standard head and sector count
1131  * is used to keep the cylinders count reasonable.
1132  */
1133 static int
1134 zvol_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1135 {
1136         zvol_state_t *zv = bdev->bd_disk->private_data;
1137         sector_t sectors = get_capacity(zv->zv_disk);
1138
1139         if (sectors > 2048) {
1140                 geo->heads = 16;
1141                 geo->sectors = 63;
1142         } else {
1143                 geo->heads = 2;
1144                 geo->sectors = 4;
1145         }
1146
1147         geo->start = 0;
1148         geo->cylinders = sectors / (geo->heads * geo->sectors);
1149
1150         return 0;
1151 }
1152
1153 static struct kobject *
1154 zvol_probe(dev_t dev, int *part, void *arg)
1155 {
1156         zvol_state_t *zv;
1157         struct kobject *kobj;
1158
1159         mutex_enter(&zvol_state_lock);
1160         zv = zvol_find_by_dev(dev);
1161         kobj = zv ? get_disk(zv->zv_disk) : NULL;
1162         mutex_exit(&zvol_state_lock);
1163
1164         return kobj;
1165 }
1166
1167 #ifdef HAVE_BDEV_BLOCK_DEVICE_OPERATIONS
1168 static struct block_device_operations zvol_ops = {
1169         .open            = zvol_open,
1170         .release         = zvol_release,
1171         .ioctl           = zvol_ioctl,
1172         .compat_ioctl    = zvol_compat_ioctl,
1173         .media_changed   = zvol_media_changed,
1174         .revalidate_disk = zvol_revalidate_disk,
1175         .getgeo          = zvol_getgeo,
1176         .owner           = THIS_MODULE,
1177 };
1178
1179 #else /* HAVE_BDEV_BLOCK_DEVICE_OPERATIONS */
1180
1181 static int
1182 zvol_open_by_inode(struct inode *inode, struct file *file)
1183 {
1184         return zvol_open(inode->i_bdev, file->f_mode);
1185 }
1186
1187 static int
1188 zvol_release_by_inode(struct inode *inode, struct file *file)
1189 {
1190         return zvol_release(inode->i_bdev->bd_disk, file->f_mode);
1191 }
1192
1193 static int
1194 zvol_ioctl_by_inode(struct inode *inode, struct file *file,
1195                     unsigned int cmd, unsigned long arg)
1196 {
1197         if (file == NULL || inode == NULL)
1198                 return -EINVAL;
1199         return zvol_ioctl(inode->i_bdev, file->f_mode, cmd, arg);
1200 }
1201
1202 # ifdef CONFIG_COMPAT
1203 static long
1204 zvol_compat_ioctl_by_inode(struct file *file,
1205                            unsigned int cmd, unsigned long arg)
1206 {
1207         if (file == NULL)
1208                 return -EINVAL;
1209         return zvol_compat_ioctl(file->f_dentry->d_inode->i_bdev,
1210                                  file->f_mode, cmd, arg);
1211 }
1212 # else
1213 # define zvol_compat_ioctl_by_inode   NULL
1214 # endif
1215
1216 static struct block_device_operations zvol_ops = {
1217         .open            = zvol_open_by_inode,
1218         .release         = zvol_release_by_inode,
1219         .ioctl           = zvol_ioctl_by_inode,
1220         .compat_ioctl    = zvol_compat_ioctl_by_inode,
1221         .media_changed   = zvol_media_changed,
1222         .revalidate_disk = zvol_revalidate_disk,
1223         .getgeo          = zvol_getgeo,
1224         .owner           = THIS_MODULE,
1225 };
1226 #endif /* HAVE_BDEV_BLOCK_DEVICE_OPERATIONS */
1227
1228 /*
1229  * Allocate memory for a new zvol_state_t and setup the required
1230  * request queue and generic disk structures for the block device.
1231  */
1232 static zvol_state_t *
1233 zvol_alloc(dev_t dev, const char *name)
1234 {
1235         zvol_state_t *zv;
1236         int error = 0;
1237
1238         zv = kmem_zalloc(sizeof (zvol_state_t), KM_SLEEP);
1239
1240         spin_lock_init(&zv->zv_lock);
1241         list_link_init(&zv->zv_next);
1242
1243         zv->zv_queue = blk_init_queue(zvol_request, &zv->zv_lock);
1244         if (zv->zv_queue == NULL)
1245                 goto out_kmem;
1246
1247 #ifdef HAVE_ELEVATOR_CHANGE
1248         error = elevator_change(zv->zv_queue, "noop");
1249 #endif /* HAVE_ELEVATOR_CHANGE */
1250         if (error) {
1251                 printk("ZFS: Unable to set \"%s\" scheduler for zvol %s: %d\n",
1252                     "noop", name, error);
1253                 goto out_queue;
1254         }
1255
1256 #ifdef HAVE_BLK_QUEUE_FLUSH
1257         blk_queue_flush(zv->zv_queue, VDEV_REQ_FLUSH | VDEV_REQ_FUA);
1258 #else
1259         blk_queue_ordered(zv->zv_queue, QUEUE_ORDERED_DRAIN, NULL);
1260 #endif /* HAVE_BLK_QUEUE_FLUSH */
1261
1262         zv->zv_disk = alloc_disk(ZVOL_MINORS);
1263         if (zv->zv_disk == NULL)
1264                 goto out_queue;
1265
1266         zv->zv_queue->queuedata = zv;
1267         zv->zv_dev = dev;
1268         zv->zv_open_count = 0;
1269         strlcpy(zv->zv_name, name, MAXNAMELEN);
1270
1271         mutex_init(&zv->zv_znode.z_range_lock, NULL, MUTEX_DEFAULT, NULL);
1272         avl_create(&zv->zv_znode.z_range_avl, zfs_range_compare,
1273             sizeof (rl_t), offsetof(rl_t, r_node));
1274         zv->zv_znode.z_is_zvol = TRUE;
1275
1276         zv->zv_disk->major = zvol_major;
1277         zv->zv_disk->first_minor = (dev & MINORMASK);
1278         zv->zv_disk->fops = &zvol_ops;
1279         zv->zv_disk->private_data = zv;
1280         zv->zv_disk->queue = zv->zv_queue;
1281         snprintf(zv->zv_disk->disk_name, DISK_NAME_LEN, "%s%d",
1282             ZVOL_DEV_NAME, (dev & MINORMASK));
1283
1284         return zv;
1285
1286 out_queue:
1287         blk_cleanup_queue(zv->zv_queue);
1288 out_kmem:
1289         kmem_free(zv, sizeof (zvol_state_t));
1290
1291         return NULL;
1292 }
1293
1294 /*
1295  * Cleanup then free a zvol_state_t which was created by zvol_alloc().
1296  */
1297 static void
1298 zvol_free(zvol_state_t *zv)
1299 {
1300         avl_destroy(&zv->zv_znode.z_range_avl);
1301         mutex_destroy(&zv->zv_znode.z_range_lock);
1302
1303         del_gendisk(zv->zv_disk);
1304         blk_cleanup_queue(zv->zv_queue);
1305         put_disk(zv->zv_disk);
1306
1307         kmem_free(zv, sizeof (zvol_state_t));
1308 }
1309
1310 static int
1311 __zvol_snapdev_hidden(const char *name)
1312 {
1313         uint64_t snapdev;
1314         char *parent;
1315         char *atp;
1316         int error = 0;
1317
1318         parent = kmem_alloc(MAXPATHLEN, KM_SLEEP);
1319         (void) strlcpy(parent, name, MAXPATHLEN);
1320
1321         if ((atp = strrchr(parent, '@')) != NULL) {
1322                 *atp = '\0';
1323                 error = dsl_prop_get_integer(parent, "snapdev", &snapdev, NULL);
1324                 if ((error == 0) && (snapdev == ZFS_SNAPDEV_HIDDEN))
1325                         error = SET_ERROR(ENODEV);
1326         }
1327         kmem_free(parent, MAXPATHLEN);
1328         return (error);
1329 }
1330
1331 static int
1332 __zvol_create_minor(const char *name, boolean_t ignore_snapdev)
1333 {
1334         zvol_state_t *zv;
1335         objset_t *os;
1336         dmu_object_info_t *doi;
1337         uint64_t volsize;
1338         unsigned minor = 0;
1339         int error = 0;
1340
1341         ASSERT(MUTEX_HELD(&zvol_state_lock));
1342
1343         zv = zvol_find_by_name(name);
1344         if (zv) {
1345                 error = SET_ERROR(EEXIST);
1346                 goto out;
1347         }
1348
1349         if (ignore_snapdev == B_FALSE) {
1350                 error = __zvol_snapdev_hidden(name);
1351                 if (error)
1352                         goto out;
1353         }
1354
1355         doi = kmem_alloc(sizeof(dmu_object_info_t), KM_SLEEP);
1356
1357         error = dmu_objset_own(name, DMU_OST_ZVOL, B_TRUE, zvol_tag, &os);
1358         if (error)
1359                 goto out_doi;
1360
1361         error = dmu_object_info(os, ZVOL_OBJ, doi);
1362         if (error)
1363                 goto out_dmu_objset_disown;
1364
1365         error = zap_lookup(os, ZVOL_ZAP_OBJ, "size", 8, 1, &volsize);
1366         if (error)
1367                 goto out_dmu_objset_disown;
1368
1369         error = zvol_find_minor(&minor);
1370         if (error)
1371                 goto out_dmu_objset_disown;
1372
1373         zv = zvol_alloc(MKDEV(zvol_major, minor), name);
1374         if (zv == NULL) {
1375                 error = SET_ERROR(EAGAIN);
1376                 goto out_dmu_objset_disown;
1377         }
1378
1379         if (dmu_objset_is_snapshot(os))
1380                 zv->zv_flags |= ZVOL_RDONLY;
1381
1382         zv->zv_volblocksize = doi->doi_data_block_size;
1383         zv->zv_volsize = volsize;
1384         zv->zv_objset = os;
1385
1386         set_capacity(zv->zv_disk, zv->zv_volsize >> 9);
1387
1388         blk_queue_max_hw_sectors(zv->zv_queue, UINT_MAX);
1389         blk_queue_max_segments(zv->zv_queue, UINT16_MAX);
1390         blk_queue_max_segment_size(zv->zv_queue, UINT_MAX);
1391         blk_queue_physical_block_size(zv->zv_queue, zv->zv_volblocksize);
1392         blk_queue_io_opt(zv->zv_queue, zv->zv_volblocksize);
1393 #ifdef HAVE_BLK_QUEUE_DISCARD
1394         blk_queue_max_discard_sectors(zv->zv_queue,
1395             (zvol_max_discard_blocks * zv->zv_volblocksize) >> 9);
1396         blk_queue_discard_granularity(zv->zv_queue, zv->zv_volblocksize);
1397         queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, zv->zv_queue);
1398 #endif
1399 #ifdef HAVE_BLK_QUEUE_NONROT
1400         queue_flag_set_unlocked(QUEUE_FLAG_NONROT, zv->zv_queue);
1401 #endif
1402
1403         if (spa_writeable(dmu_objset_spa(os))) {
1404                 if (zil_replay_disable)
1405                         zil_destroy(dmu_objset_zil(os), B_FALSE);
1406                 else
1407                         zil_replay(os, zv, zvol_replay_vector);
1408         }
1409
1410         zv->zv_objset = NULL;
1411 out_dmu_objset_disown:
1412         dmu_objset_disown(os, zvol_tag);
1413 out_doi:
1414         kmem_free(doi, sizeof(dmu_object_info_t));
1415 out:
1416
1417         if (error == 0) {
1418                 zvol_insert(zv);
1419                 add_disk(zv->zv_disk);
1420         }
1421
1422         return (error);
1423 }
1424
1425 /*
1426  * Create a block device minor node and setup the linkage between it
1427  * and the specified volume.  Once this function returns the block
1428  * device is live and ready for use.
1429  */
1430 int
1431 zvol_create_minor(const char *name)
1432 {
1433         int error;
1434
1435         mutex_enter(&zvol_state_lock);
1436         error = __zvol_create_minor(name, B_FALSE);
1437         mutex_exit(&zvol_state_lock);
1438
1439         return (error);
1440 }
1441
1442 static int
1443 __zvol_remove_minor(const char *name)
1444 {
1445         zvol_state_t *zv;
1446
1447         ASSERT(MUTEX_HELD(&zvol_state_lock));
1448
1449         zv = zvol_find_by_name(name);
1450         if (zv == NULL)
1451                 return (SET_ERROR(ENXIO));
1452
1453         if (zv->zv_open_count > 0)
1454                 return (SET_ERROR(EBUSY));
1455
1456         zvol_remove(zv);
1457         zvol_free(zv);
1458
1459         return (0);
1460 }
1461
1462 /*
1463  * Remove a block device minor node for the specified volume.
1464  */
1465 int
1466 zvol_remove_minor(const char *name)
1467 {
1468         int error;
1469
1470         mutex_enter(&zvol_state_lock);
1471         error = __zvol_remove_minor(name);
1472         mutex_exit(&zvol_state_lock);
1473
1474         return (error);
1475 }
1476
1477 static int
1478 zvol_create_minors_cb(const char *dsname, void *arg)
1479 {
1480         if (strchr(dsname, '/') == NULL)
1481                 return 0;
1482
1483         (void) __zvol_create_minor(dsname, B_FALSE);
1484         return (0);
1485 }
1486
1487 /*
1488  * Create minors for specified pool, if pool is NULL create minors
1489  * for all available pools.
1490  */
1491 int
1492 zvol_create_minors(char *pool)
1493 {
1494         spa_t *spa = NULL;
1495         int error = 0;
1496
1497         if (zvol_inhibit_dev)
1498                 return (0);
1499
1500         mutex_enter(&zvol_state_lock);
1501         if (pool) {
1502                 error = dmu_objset_find(pool, zvol_create_minors_cb,
1503                     NULL, DS_FIND_CHILDREN | DS_FIND_SNAPSHOTS);
1504         } else {
1505                 mutex_enter(&spa_namespace_lock);
1506                 while ((spa = spa_next(spa)) != NULL) {
1507                         error = dmu_objset_find(spa_name(spa), zvol_create_minors_cb, NULL,
1508                             DS_FIND_CHILDREN | DS_FIND_SNAPSHOTS);
1509                         if (error)
1510                                 break;
1511                 }
1512                 mutex_exit(&spa_namespace_lock);
1513         }
1514         mutex_exit(&zvol_state_lock);
1515
1516         return error;
1517 }
1518
1519 /*
1520  * Remove minors for specified pool, if pool is NULL remove all minors.
1521  */
1522 void
1523 zvol_remove_minors(const char *pool)
1524 {
1525         zvol_state_t *zv, *zv_next;
1526         char *str;
1527
1528         if (zvol_inhibit_dev)
1529                 return;
1530
1531         str = kmem_zalloc(MAXNAMELEN, KM_SLEEP);
1532         if (pool) {
1533                 (void) strncpy(str, pool, strlen(pool));
1534                 (void) strcat(str, "/");
1535         }
1536
1537         mutex_enter(&zvol_state_lock);
1538         for (zv = list_head(&zvol_state_list); zv != NULL; zv = zv_next) {
1539                 zv_next = list_next(&zvol_state_list, zv);
1540
1541                 if (pool == NULL || !strncmp(str, zv->zv_name, strlen(str))) {
1542                         zvol_remove(zv);
1543                         zvol_free(zv);
1544                 }
1545         }
1546         mutex_exit(&zvol_state_lock);
1547         kmem_free(str, MAXNAMELEN);
1548 }
1549
1550 static int
1551 snapdev_snapshot_changed_cb(const char *dsname, void *arg) {
1552         uint64_t snapdev = *(uint64_t *) arg;
1553
1554         if (strchr(dsname, '@') == NULL)
1555                 return 0;
1556
1557         switch (snapdev) {
1558                 case ZFS_SNAPDEV_VISIBLE:
1559                         mutex_enter(&zvol_state_lock);
1560                         (void) __zvol_create_minor(dsname, B_TRUE);
1561                         mutex_exit(&zvol_state_lock);
1562                         break;
1563                 case ZFS_SNAPDEV_HIDDEN:
1564                         (void) zvol_remove_minor(dsname);
1565                         break;
1566         }
1567         return 0;
1568 }
1569
1570 int
1571 zvol_set_snapdev(const char *dsname, uint64_t snapdev) {
1572         (void) dmu_objset_find((char *) dsname, snapdev_snapshot_changed_cb,
1573                 &snapdev, DS_FIND_SNAPSHOTS | DS_FIND_CHILDREN);
1574         /* caller should continue to modify snapdev property */
1575         return (-1);
1576 }
1577
1578
1579 int
1580 zvol_init(void)
1581 {
1582         int error;
1583
1584         list_create(&zvol_state_list, sizeof (zvol_state_t),
1585                     offsetof(zvol_state_t, zv_next));
1586         mutex_init(&zvol_state_lock, NULL, MUTEX_DEFAULT, NULL);
1587
1588         zvol_taskq = taskq_create(ZVOL_DRIVER, zvol_threads, maxclsyspri,
1589                                   zvol_threads, INT_MAX, TASKQ_PREPOPULATE);
1590         if (zvol_taskq == NULL) {
1591                 printk(KERN_INFO "ZFS: taskq_create() failed\n");
1592                 error = -ENOMEM;
1593                 goto out1;
1594         }
1595
1596         error = register_blkdev(zvol_major, ZVOL_DRIVER);
1597         if (error) {
1598                 printk(KERN_INFO "ZFS: register_blkdev() failed %d\n", error);
1599                 goto out2;
1600         }
1601
1602         blk_register_region(MKDEV(zvol_major, 0), 1UL << MINORBITS,
1603                             THIS_MODULE, zvol_probe, NULL, NULL);
1604
1605         return (0);
1606
1607 out2:
1608         taskq_destroy(zvol_taskq);
1609 out1:
1610         mutex_destroy(&zvol_state_lock);
1611         list_destroy(&zvol_state_list);
1612
1613         return (error);
1614 }
1615
1616 void
1617 zvol_fini(void)
1618 {
1619         zvol_remove_minors(NULL);
1620         blk_unregister_region(MKDEV(zvol_major, 0), 1UL << MINORBITS);
1621         unregister_blkdev(zvol_major, ZVOL_DRIVER);
1622         taskq_destroy(zvol_taskq);
1623         mutex_destroy(&zvol_state_lock);
1624         list_destroy(&zvol_state_list);
1625 }
1626
1627 module_param(zvol_inhibit_dev, uint, 0644);
1628 MODULE_PARM_DESC(zvol_inhibit_dev, "Do not create zvol device nodes");
1629
1630 module_param(zvol_major, uint, 0444);
1631 MODULE_PARM_DESC(zvol_major, "Major number for zvol device");
1632
1633 module_param(zvol_threads, uint, 0444);
1634 MODULE_PARM_DESC(zvol_threads, "Number of threads for zvol device");
1635
1636 module_param(zvol_max_discard_blocks, ulong, 0444);
1637 MODULE_PARM_DESC(zvol_max_discard_blocks, "Max number of blocks to discard at once");