• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /**
2  * libf2fs_zoned.c
3  *
4  * Copyright (c) 2016 Western Digital Corporation.
5  * Written by: Damien Le Moal <damien.lemoal@wdc.com>
6  *
7  * Dual licensed under the GPL or LGPL version 2 licenses.
8  */
9 #ifndef _LARGEFILE64_SOURCE
10 #define _LARGEFILE64_SOURCE
11 #endif
12 
13 #include <f2fs_fs.h>
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <string.h>
17 #include <errno.h>
18 #include <unistd.h>
19 #include <fcntl.h>
20 #include <sys/stat.h>
21 #ifdef HAVE_SYS_SYSMACROS_H
22 #include <sys/sysmacros.h>
23 #endif
24 #ifdef HAVE_LINUX_LIMITS_H
25 #include <linux/limits.h>
26 #endif
27 #ifdef HAVE_SYS_IOCTL_H
28 #include <sys/ioctl.h>
29 #endif
30 #include <libgen.h>
31 
32 #ifdef HAVE_LINUX_BLKZONED_H
33 
get_sysfs_path(struct device_info * dev,const char * attr,char * buf,size_t buflen)34 int get_sysfs_path(struct device_info *dev, const char *attr,
35 		   char *buf, size_t buflen)
36 {
37 	struct stat statbuf;
38 	char str[PATH_MAX];
39 	char sysfs_path[PATH_MAX];
40 	ssize_t len;
41 	char *delim;
42 	int ret;
43 
44 	if (stat(dev->path, &statbuf) < 0)
45 		return -1;
46 
47 	snprintf(str, sizeof(str), "/sys/dev/block/%d:%d",
48 		 major(statbuf.st_rdev), minor(statbuf.st_rdev));
49 	len = readlink(str, buf, buflen - 1);
50 	if (len < 0)
51 		return -1;
52 	buf[len] = '\0';
53 
54 	ret = snprintf(sysfs_path, sizeof(sysfs_path),
55 		       "/sys/dev/block/%s", buf);
56 	if (ret >= sizeof(sysfs_path))
57 		return -1;
58 
59 	/* Test if the device is a partition */
60 	ret = snprintf(str, sizeof(str), "%s/partition", sysfs_path);
61 	if (ret >= sizeof(str))
62 		return -1;
63 	ret = stat(str, &statbuf);
64 	if (ret) {
65 		if (errno == ENOENT) {
66 			/* Not a partition */
67 			goto out;
68 		}
69 		return -1;
70 	}
71 
72 	/*
73 	 * The device is a partition: remove the device name from the
74 	 * attribute file path to obtain the sysfs path of the holder device.
75 	 *   e.g.:  /sys/dev/block/.../sda/sda1 -> /sys/dev/block/.../sda
76 	 */
77 	delim = strrchr(sysfs_path, '/');
78 	if (!delim)
79 		return -1;
80 	*delim = '\0';
81 
82 out:
83 	ret = snprintf(buf, buflen, "%s/%s", sysfs_path, attr);
84 	if (ret >= buflen)
85 		return -1;
86 
87 	return 0;
88 }
89 
f2fs_get_zoned_model(int i)90 int f2fs_get_zoned_model(int i)
91 {
92 	struct device_info *dev = c.devices + i;
93 	char str[PATH_MAX];
94 	FILE *file;
95 	int res;
96 
97 	/* Check that this is a zoned block device */
98 	res = get_sysfs_path(dev, "queue/zoned", str, sizeof(str));
99 	if (res != 0) {
100 		MSG(0, "\tInfo: can't find /sys, assuming normal block device\n");
101 		dev->zoned_model = F2FS_ZONED_NONE;
102 		return 0;
103 	}
104 
105 	file = fopen(str, "r");
106 	if (!file) {
107 		/*
108 		 * The kernel does not support zoned block devices, but we have
109 		 * a block device file. This means that if the zoned file is
110 		 * not found, then the device is not zoned or is zoned but can
111 		 * be randomly written (i.e. host-aware zoned model).
112 		 * Treat the device as a regular block device. Otherwise, signal
113 		 * the failure to verify the disk zone model.
114 		 */
115 		if (errno == ENOENT) {
116 			dev->zoned_model = F2FS_ZONED_NONE;
117 			return 0;
118 		}
119 		MSG(0, "\tError: Failed to check the device zoned model\n");
120 		return -1;
121 	}
122 
123 	memset(str, 0, sizeof(str));
124 	res = fscanf(file, "%s", str);
125 	fclose(file);
126 
127 	if (res != 1) {
128 		MSG(0, "\tError: Failed to parse the device zoned model\n");
129 		return -1;
130 	}
131 
132 	if (strcmp(str, "none") == 0) {
133 		/* Regular block device */
134 		dev->zoned_model = F2FS_ZONED_NONE;
135 	} else if (strcmp(str, "host-aware") == 0) {
136 		/* Host-aware zoned block device: can be randomly written */
137 		dev->zoned_model = F2FS_ZONED_HA;
138 	} else if (strcmp(str, "host-managed") == 0) {
139 		/* Host-managed zoned block device: sequential writes needed */
140 		dev->zoned_model = F2FS_ZONED_HM;
141 	} else {
142 		MSG(0, "\tError: Unsupported device zoned model\n");
143 		return -1;
144 	}
145 
146 	return 0;
147 }
148 
f2fs_get_zone_chunk_sectors(struct device_info * dev)149 uint32_t f2fs_get_zone_chunk_sectors(struct device_info *dev)
150 {
151 	uint32_t sectors;
152 	char str[PATH_MAX];
153 	FILE *file;
154 	int res;
155 
156 	res = get_sysfs_path(dev, "queue/chunk_sectors", str, sizeof(str));
157 	if (res != 0) {
158 		MSG(0, "\tError: Failed to get device sysfs attribute path\n");
159 		return 0;
160 	}
161 
162 	file = fopen(str, "r");
163 	if (!file)
164 		return 0;
165 
166 	memset(str, 0, sizeof(str));
167 	res = fscanf(file, "%s", str);
168 	fclose(file);
169 
170 	if (res != 1)
171 		return 0;
172 
173 	sectors = atoi(str);
174 
175 	return sectors;
176 }
177 
f2fs_get_zone_blocks(int i)178 int f2fs_get_zone_blocks(int i)
179 {
180 	struct device_info *dev = c.devices + i;
181 	uint64_t sectors;
182 
183 	/* Get zone size */
184 	dev->zone_blocks = 0;
185 
186 	sectors = f2fs_get_zone_chunk_sectors(dev);
187 	if (!sectors)
188 		return -1;
189 
190 	dev->zone_size = sectors << SECTOR_SHIFT;
191 	dev->zone_blocks = sectors >> (F2FS_BLKSIZE_BITS - SECTOR_SHIFT);
192 	sectors = dev->zone_size / c.sector_size;
193 
194 	/*
195 	 * Total number of zones: there may
196 	 * be a last smaller runt zone.
197 	 */
198 	dev->nr_zones = dev->total_sectors / sectors;
199 	if (dev->total_sectors % sectors)
200 		dev->nr_zones++;
201 
202 	return 0;
203 }
204 
f2fs_report_zone(int i,uint64_t sector,struct blk_zone * blkzone)205 int f2fs_report_zone(int i, uint64_t sector, struct blk_zone *blkzone)
206 {
207 	struct one_zone_report {
208 		struct blk_zone_report	rep;
209 		struct blk_zone		zone;
210 	} *rep;
211 	int ret = -1;
212 
213 	static_assert(sizeof(*rep) == sizeof(rep->rep) + sizeof(rep->zone), "");
214 
215 	rep = calloc(1, sizeof(*rep));
216 	if (!rep) {
217 		ERR_MSG("No memory for report zones\n");
218 		return -ENOMEM;
219 	}
220 
221 	rep->rep = (struct blk_zone_report){
222 		.sector = sector,
223 		.nr_zones = 1,
224 	};
225 	ret = ioctl(c.devices[i].fd, BLKREPORTZONE, rep);
226 	if (ret != 0) {
227 		ret = -errno;
228 		ERR_MSG("ioctl BLKREPORTZONE failed: errno=%d\n", errno);
229 		goto out;
230 	}
231 
232 	*blkzone = rep->zone;
233 out:
234 	free(rep);
235 	return ret;
236 }
237 
238 #define F2FS_REPORT_ZONES_BUFSZ	524288
239 
f2fs_report_zones(int j,report_zones_cb_t * report_zones_cb,void * opaque)240 int f2fs_report_zones(int j, report_zones_cb_t *report_zones_cb, void *opaque)
241 {
242 	struct device_info *dev = c.devices + j;
243 	struct blk_zone_report *rep;
244 	struct blk_zone *blkz;
245 	unsigned int i, n = 0;
246 	uint64_t total_sectors = (dev->total_sectors * c.sector_size)
247 		>> SECTOR_SHIFT;
248 	uint64_t sector = 0;
249 	int ret = -1;
250 
251 	rep = malloc(F2FS_REPORT_ZONES_BUFSZ);
252 	if (!rep) {
253 		ERR_MSG("No memory for report zones\n");
254 		return -ENOMEM;
255 	}
256 
257 	while (sector < total_sectors) {
258 
259 		/* Get zone info */
260 		rep->sector = sector;
261 		rep->nr_zones = (F2FS_REPORT_ZONES_BUFSZ - sizeof(struct blk_zone_report))
262 			/ sizeof(struct blk_zone);
263 
264 		ret = ioctl(dev->fd, BLKREPORTZONE, rep);
265 		if (ret != 0) {
266 			ret = -errno;
267 			ERR_MSG("ioctl BLKREPORTZONE failed: errno=%d\n",
268 				errno);
269 			goto out;
270 		}
271 
272 		if (!rep->nr_zones) {
273 			ret = -EIO;
274 			ERR_MSG("Unexpected ioctl BLKREPORTZONE result\n");
275 			goto out;
276 		}
277 
278 		blkz = (struct blk_zone *)(rep + 1);
279 		for (i = 0; i < rep->nr_zones; i++) {
280 			ret = report_zones_cb(n, blkz, opaque);
281 			if (ret)
282 				goto out;
283 			sector = blk_zone_sector(blkz) + blk_zone_length(blkz);
284 			n++;
285 			blkz++;
286 		}
287 	}
288 out:
289 	free(rep);
290 	return ret;
291 }
292 
f2fs_check_zones(int j)293 int f2fs_check_zones(int j)
294 {
295 	struct device_info *dev = c.devices + j;
296 	struct blk_zone_report *rep;
297 	struct blk_zone *blkz;
298 	unsigned int i, n = 0;
299 	uint64_t total_sectors;
300 	uint64_t sector;
301 	int last_is_conv = 1;
302 	int ret = -1;
303 
304 	rep = malloc(F2FS_REPORT_ZONES_BUFSZ);
305 	if (!rep) {
306 		ERR_MSG("No memory for report zones\n");
307 		return -ENOMEM;
308 	}
309 
310 	dev->zone_cap_blocks = malloc(dev->nr_zones * sizeof(size_t));
311 	if (!dev->zone_cap_blocks) {
312 		ERR_MSG("No memory for zone capacity list.\n");
313 		return -ENOMEM;
314 	}
315 	memset(dev->zone_cap_blocks, 0, (dev->nr_zones * sizeof(size_t)));
316 
317 	dev->nr_rnd_zones = 0;
318 	sector = 0;
319 	total_sectors = (dev->total_sectors * c.sector_size) >> 9;
320 
321 	while (sector < total_sectors) {
322 
323 		/* Get zone info */
324 		memset(rep, 0, F2FS_REPORT_ZONES_BUFSZ);
325 		rep->sector = sector;
326 		rep->nr_zones = (F2FS_REPORT_ZONES_BUFSZ - sizeof(struct blk_zone_report))
327 			/ sizeof(struct blk_zone);
328 
329 		ret = ioctl(dev->fd, BLKREPORTZONE, rep);
330 		if (ret != 0) {
331 			ret = -errno;
332 			ERR_MSG("ioctl BLKREPORTZONE failed\n");
333 			goto out;
334 		}
335 
336 		if (!rep->nr_zones)
337 			break;
338 
339 		blkz = (struct blk_zone *)(rep + 1);
340 		for (i = 0; i < rep->nr_zones && sector < total_sectors; i++) {
341 
342 			if (blk_zone_cond(blkz) == BLK_ZONE_COND_READONLY ||
343 			    blk_zone_cond(blkz) == BLK_ZONE_COND_OFFLINE)
344 				last_is_conv = 0;
345 			if (blk_zone_conv(blkz) ||
346 			    blk_zone_seq_pref(blkz)) {
347 				if (last_is_conv)
348 					dev->nr_rnd_zones++;
349 			} else {
350 				last_is_conv = 0;
351 			}
352 
353 			if (blk_zone_conv(blkz)) {
354 				DBG(2,
355 				    "Zone %05u: Conventional, cond 0x%x (%s), sector %llu, %llu sectors\n",
356 				    n,
357 				    blk_zone_cond(blkz),
358 				    blk_zone_cond_str(blkz),
359 				    blk_zone_sector(blkz),
360 				    blk_zone_length(blkz));
361 				dev->zone_cap_blocks[n] =
362 					blk_zone_length(blkz) >>
363 					(F2FS_BLKSIZE_BITS - SECTOR_SHIFT);
364 			} else {
365 				DBG(2,
366 				    "Zone %05u: type 0x%x (%s), cond 0x%x (%s),"
367 				    " need_reset %d, non_seq %d, sector %llu,"
368 				    " %llu sectors, capacity %llu,"
369 				    " wp sector %llu\n",
370 				    n,
371 				    blk_zone_type(blkz),
372 				    blk_zone_type_str(blkz),
373 				    blk_zone_cond(blkz),
374 				    blk_zone_cond_str(blkz),
375 				    blk_zone_need_reset(blkz),
376 				    blk_zone_non_seq(blkz),
377 				    blk_zone_sector(blkz),
378 				    blk_zone_length(blkz),
379 				    blk_zone_capacity(blkz, rep->flags),
380 				    blk_zone_wp_sector(blkz));
381 				dev->zone_cap_blocks[n] =
382 					blk_zone_capacity(blkz, rep->flags) >>
383 					(F2FS_BLKSIZE_BITS - SECTOR_SHIFT);
384 			}
385 
386 			sector = blk_zone_sector(blkz) + blk_zone_length(blkz);
387 			n++;
388 			blkz++;
389 		}
390 	}
391 
392 	if (sector != total_sectors) {
393 		ERR_MSG("Invalid zones: last sector reported is %llu, expected %llu\n",
394 			(unsigned long long)(sector << 9) / c.sector_size,
395 			(unsigned long long)dev->total_sectors);
396 		ret = -1;
397 		goto out;
398 	}
399 
400 	if (n != dev->nr_zones) {
401 		ERR_MSG("Inconsistent number of zones: expected %u zones, got %u\n",
402 			dev->nr_zones, n);
403 		ret = -1;
404 		goto out;
405 	}
406 
407 	/*
408 	 * For a multi-device volume, fixed position metadata blocks are
409 	 * stored * only on the first device of the volume. Checking for the
410 	 * presence of * conventional zones (randomly writeabl zones) for
411 	 * storing these blocks * on a host-managed device is thus needed only
412 	 * for the device index 0.
413 	 */
414 	if (j == 0 && dev->zoned_model == F2FS_ZONED_HM &&
415 			!dev->nr_rnd_zones) {
416 		ERR_MSG("No conventional zone for super block\n");
417 		ret = -1;
418 	}
419 out:
420 	free(rep);
421 	return ret;
422 }
423 
f2fs_reset_zone(int i,void * blkzone)424 int f2fs_reset_zone(int i, void *blkzone)
425 {
426 	struct blk_zone *blkz = (struct blk_zone *)blkzone;
427 	struct device_info *dev = c.devices + i;
428 	struct blk_zone_range range;
429 	int ret;
430 
431 	if (!blk_zone_seq(blkz) || blk_zone_empty(blkz))
432 		return 0;
433 
434 	/* Non empty sequential zone: reset */
435 	range.sector = blk_zone_sector(blkz);
436 	range.nr_sectors = blk_zone_length(blkz);
437 	ret = ioctl(dev->fd, BLKRESETZONE, &range);
438 	if (ret != 0) {
439 		ret = -errno;
440 		ERR_MSG("ioctl BLKRESETZONE failed: errno=%d\n", errno);
441 	}
442 
443 	return ret;
444 }
445 
f2fs_reset_zones(int j)446 int f2fs_reset_zones(int j)
447 {
448 	struct device_info *dev = c.devices + j;
449 	struct blk_zone_report *rep;
450 	struct blk_zone *blkz;
451 	struct blk_zone_range range;
452 	uint64_t total_sectors;
453 	uint64_t sector;
454 	unsigned int i;
455 	int ret = -1;
456 
457 	rep = malloc(F2FS_REPORT_ZONES_BUFSZ);
458 	if (!rep) {
459 		ERR_MSG("No memory for report zones\n");
460 		return -1;
461 	}
462 
463 	sector = 0;
464 	total_sectors = (dev->total_sectors * c.sector_size) >> 9;
465 	while (sector < total_sectors) {
466 
467 		/* Get zone info */
468 		memset(rep, 0, F2FS_REPORT_ZONES_BUFSZ);
469 		rep->sector = sector;
470 		rep->nr_zones = (F2FS_REPORT_ZONES_BUFSZ - sizeof(struct blk_zone_report))
471 			/ sizeof(struct blk_zone);
472 
473 		ret = ioctl(dev->fd, BLKREPORTZONE, rep);
474 		if (ret != 0) {
475 			ret = -errno;
476 			ERR_MSG("ioctl BLKREPORTZONES failed\n");
477 			goto out;
478 		}
479 
480 		if (!rep->nr_zones)
481 			break;
482 
483 		blkz = (struct blk_zone *)(rep + 1);
484 		for (i = 0; i < rep->nr_zones && sector < total_sectors; i++) {
485 			if (blk_zone_seq(blkz) &&
486 			    !blk_zone_empty(blkz)) {
487 				/* Non empty sequential zone: reset */
488 				range.sector = blk_zone_sector(blkz);
489 				range.nr_sectors = blk_zone_length(blkz);
490 				ret = ioctl(dev->fd, BLKRESETZONE, &range);
491 				if (ret != 0) {
492 					ret = -errno;
493 					ERR_MSG("ioctl BLKRESETZONE failed\n");
494 					goto out;
495 				}
496 			}
497 			sector = blk_zone_sector(blkz) + blk_zone_length(blkz);
498 			blkz++;
499 		}
500 	}
501 out:
502 	free(rep);
503 	if (!ret)
504 		MSG(0, "Info: Discarded %"PRIu64" MB\n", (sector << 9) >> 20);
505 	return ret;
506 }
507 
f2fs_get_usable_segments(struct f2fs_super_block * sb)508 uint32_t f2fs_get_usable_segments(struct f2fs_super_block *sb)
509 {
510 #ifdef HAVE_BLK_ZONE_REP_V2
511 	int i, j;
512 	uint32_t usable_segs = 0, zone_segs;
513 
514 	if (c.func == RESIZE)
515 		return get_sb(segment_count_main);
516 
517 	for (i = 0; i < c.ndevs; i++) {
518 		if (c.devices[i].zoned_model != F2FS_ZONED_HM) {
519 			usable_segs += c.devices[i].total_segments;
520 			continue;
521 		}
522 		for (j = 0; j < c.devices[i].nr_zones; j++) {
523 			zone_segs = c.devices[i].zone_cap_blocks[j] >>
524 					get_sb(log_blocks_per_seg);
525 			if (c.devices[i].zone_cap_blocks[j] %
526 						DEFAULT_BLOCKS_PER_SEGMENT)
527 				usable_segs += zone_segs + 1;
528 			else
529 				usable_segs += zone_segs;
530 		}
531 	}
532 	usable_segs -= (get_sb(main_blkaddr) - get_sb(segment0_blkaddr)) >>
533 						get_sb(log_blocks_per_seg);
534 	return usable_segs;
535 #endif
536 	return get_sb(segment_count_main);
537 }
538 
539 #else
540 
f2fs_report_zone(int i,uint64_t UNUSED (sector),struct blk_zone * UNUSED (blkzone))541 int f2fs_report_zone(int i, uint64_t UNUSED(sector),
542 		     struct blk_zone *UNUSED(blkzone))
543 {
544 	ERR_MSG("%d: Unsupported zoned block device\n", i);
545 	return -1;
546 }
547 
f2fs_report_zones(int i,report_zones_cb_t * UNUSED (report_zones_cb),void * UNUSED (opaque))548 int f2fs_report_zones(int i, report_zones_cb_t *UNUSED(report_zones_cb),
549 					void *UNUSED(opaque))
550 {
551 	ERR_MSG("%d: Unsupported zoned block device\n", i);
552 	return -1;
553 }
554 
f2fs_get_zoned_model(int i)555 int f2fs_get_zoned_model(int i)
556 {
557 	struct device_info *dev = c.devices + i;
558 
559 	c.zoned_mode = 0;
560 	dev->zoned_model = F2FS_ZONED_NONE;
561 	return 0;
562 }
563 
f2fs_get_zone_blocks(int i)564 int f2fs_get_zone_blocks(int i)
565 {
566 	struct device_info *dev = c.devices + i;
567 
568 	c.zoned_mode = 0;
569 	dev->nr_zones = 0;
570 	dev->zone_blocks = 0;
571 	dev->zoned_model = F2FS_ZONED_NONE;
572 
573 	return 0;
574 }
575 
f2fs_check_zones(int i)576 int f2fs_check_zones(int i)
577 {
578 	ERR_MSG("%d: Unsupported zoned block device\n", i);
579 	return -1;
580 }
581 
f2fs_reset_zone(int i,void * UNUSED (blkzone))582 int f2fs_reset_zone(int i, void *UNUSED(blkzone))
583 {
584 	ERR_MSG("%d: Unsupported zoned block device\n", i);
585 	return -1;
586 }
587 
f2fs_reset_zones(int i)588 int f2fs_reset_zones(int i)
589 {
590 	ERR_MSG("%d: Unsupported zoned block device\n", i);
591 	return -1;
592 }
593 
f2fs_get_usable_segments(struct f2fs_super_block * sb)594 uint32_t f2fs_get_usable_segments(struct f2fs_super_block *sb)
595 {
596 	return get_sb(segment_count_main);
597 }
598 #endif
599 
600