1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2013 4 * Minchan Kim <minchan@kernel.org> 5 */ 6 #include <linux/types.h> 7 #include <linux/mutex.h> 8 #include <linux/slab.h> 9 #include <linux/bio.h> 10 #include <linux/sched.h> 11 #include <linux/wait.h> 12 #include <linux/cpumask.h> 13 14 #include "squashfs_fs.h" 15 #include "squashfs_fs_sb.h" 16 #include "decompressor.h" 17 #include "squashfs.h" 18 19 /* 20 * This file implements multi-threaded decompression in the 21 * decompressor framework 22 */ 23 24 25 /* 26 * The reason that multiply two is that a CPU can request new I/O 27 * while it is waiting previous request. 28 */ 29 #define MAX_DECOMPRESSOR (num_online_cpus() * 2) 30 31 32 static int squashfs_max_decompressors(void) 33 { 34 return MAX_DECOMPRESSOR; 35 } 36 37 struct squashfs_stream { 38 void *comp_opts; 39 struct list_head strm_list; 40 struct mutex mutex; 41 int avail_decomp; 42 wait_queue_head_t wait; 43 }; 44 45 46 struct decomp_stream { 47 void *stream; 48 struct list_head list; 49 }; 50 51 52 static void put_decomp_stream(struct decomp_stream *decomp_strm, 53 struct squashfs_stream *stream) 54 { 55 mutex_lock(&stream->mutex); 56 list_add(&decomp_strm->list, &stream->strm_list); 57 mutex_unlock(&stream->mutex); 58 wake_up(&stream->wait); 59 } 60 61 static void *squashfs_decompressor_create(struct squashfs_sb_info *msblk, 62 void *comp_opts) 63 { 64 struct squashfs_stream *stream; 65 struct decomp_stream *decomp_strm = NULL; 66 int err = -ENOMEM; 67 68 stream = kzalloc(sizeof(*stream), GFP_KERNEL); 69 if (!stream) 70 goto out; 71 72 stream->comp_opts = comp_opts; 73 mutex_init(&stream->mutex); 74 INIT_LIST_HEAD(&stream->strm_list); 75 init_waitqueue_head(&stream->wait); 76 77 /* 78 * We should have a decompressor at least as default 79 * so if we fail to allocate new decompressor dynamically, 80 * we could always fall back to default decompressor and 81 * file system works. 82 */ 83 decomp_strm = kmalloc(sizeof(*decomp_strm), GFP_KERNEL); 84 if (!decomp_strm) 85 goto out; 86 87 decomp_strm->stream = msblk->decompressor->init(msblk, 88 stream->comp_opts); 89 if (IS_ERR(decomp_strm->stream)) { 90 err = PTR_ERR(decomp_strm->stream); 91 goto out; 92 } 93 94 list_add(&decomp_strm->list, &stream->strm_list); 95 stream->avail_decomp = 1; 96 return stream; 97 98 out: 99 kfree(decomp_strm); 100 kfree(stream); 101 return ERR_PTR(err); 102 } 103 104 105 static void squashfs_decompressor_destroy(struct squashfs_sb_info *msblk) 106 { 107 struct squashfs_stream *stream = msblk->stream; 108 if (stream) { 109 struct decomp_stream *decomp_strm; 110 111 while (!list_empty(&stream->strm_list)) { 112 decomp_strm = list_entry(stream->strm_list.prev, 113 struct decomp_stream, list); 114 list_del(&decomp_strm->list); 115 msblk->decompressor->free(decomp_strm->stream); 116 kfree(decomp_strm); 117 stream->avail_decomp--; 118 } 119 WARN_ON(stream->avail_decomp); 120 kfree(stream->comp_opts); 121 kfree(stream); 122 } 123 } 124 125 126 static struct decomp_stream *get_decomp_stream(struct squashfs_sb_info *msblk, 127 struct squashfs_stream *stream) 128 { 129 struct decomp_stream *decomp_strm; 130 131 while (1) { 132 mutex_lock(&stream->mutex); 133 134 /* There is available decomp_stream */ 135 if (!list_empty(&stream->strm_list)) { 136 decomp_strm = list_entry(stream->strm_list.prev, 137 struct decomp_stream, list); 138 list_del(&decomp_strm->list); 139 mutex_unlock(&stream->mutex); 140 break; 141 } 142 143 /* 144 * If there is no available decomp and already full, 145 * let's wait for releasing decomp from other users. 146 */ 147 if (stream->avail_decomp >= msblk->max_thread_num) 148 goto wait; 149 150 /* Let's allocate new decomp */ 151 decomp_strm = kmalloc(sizeof(*decomp_strm), GFP_KERNEL); 152 if (!decomp_strm) 153 goto wait; 154 155 decomp_strm->stream = msblk->decompressor->init(msblk, 156 stream->comp_opts); 157 if (IS_ERR(decomp_strm->stream)) { 158 kfree(decomp_strm); 159 goto wait; 160 } 161 162 stream->avail_decomp++; 163 WARN_ON(stream->avail_decomp > msblk->max_thread_num); 164 165 mutex_unlock(&stream->mutex); 166 break; 167 wait: 168 /* 169 * If system memory is tough, let's for other's 170 * releasing instead of hurting VM because it could 171 * make page cache thrashing. 172 */ 173 mutex_unlock(&stream->mutex); 174 wait_event(stream->wait, 175 !list_empty(&stream->strm_list)); 176 } 177 178 return decomp_strm; 179 } 180 181 182 static int squashfs_decompress(struct squashfs_sb_info *msblk, struct bio *bio, 183 int offset, int length, 184 struct squashfs_page_actor *output) 185 { 186 int res; 187 struct squashfs_stream *stream = msblk->stream; 188 struct decomp_stream *decomp_stream = get_decomp_stream(msblk, stream); 189 res = msblk->decompressor->decompress(msblk, decomp_stream->stream, 190 bio, offset, length, output); 191 put_decomp_stream(decomp_stream, stream); 192 if (res < 0) 193 ERROR("%s decompression failed, data probably corrupt\n", 194 msblk->decompressor->name); 195 return res; 196 } 197 198 const struct squashfs_decompressor_thread_ops squashfs_decompressor_multi = { 199 .create = squashfs_decompressor_create, 200 .destroy = squashfs_decompressor_destroy, 201 .decompress = squashfs_decompress, 202 .max_decompressors = squashfs_max_decompressors, 203 }; 204