183d290c5STom Rini // SPDX-License-Identifier: GPL-2.0+
29eefe2a2SStefan Roese /*
39eefe2a2SStefan Roese * This file is part of UBIFS.
49eefe2a2SStefan Roese *
59eefe2a2SStefan Roese * Copyright (C) 2006-2008 Nokia Corporation
69eefe2a2SStefan Roese *
79eefe2a2SStefan Roese * Authors: Adrian Hunter
89eefe2a2SStefan Roese * Artem Bityutskiy (Битюцкий Артём)
99eefe2a2SStefan Roese */
109eefe2a2SStefan Roese
119eefe2a2SStefan Roese /*
129eefe2a2SStefan Roese * This file implements the scan which is a general-purpose function for
139eefe2a2SStefan Roese * determining what nodes are in an eraseblock. The scan is used to replay the
149eefe2a2SStefan Roese * journal, to do garbage collection. for the TNC in-the-gaps method, and by
159eefe2a2SStefan Roese * debugging functions.
169eefe2a2SStefan Roese */
179eefe2a2SStefan Roese
18ff94bc40SHeiko Schocher #ifdef __UBOOT__
19*f8c987f8SAlexey Brodkin #include <hexdump.h>
20ff94bc40SHeiko Schocher #include <linux/err.h>
21ff94bc40SHeiko Schocher #endif
229eefe2a2SStefan Roese #include "ubifs.h"
239eefe2a2SStefan Roese
249eefe2a2SStefan Roese /**
259eefe2a2SStefan Roese * scan_padding_bytes - scan for padding bytes.
269eefe2a2SStefan Roese * @buf: buffer to scan
279eefe2a2SStefan Roese * @len: length of buffer
289eefe2a2SStefan Roese *
299eefe2a2SStefan Roese * This function returns the number of padding bytes on success and
309eefe2a2SStefan Roese * %SCANNED_GARBAGE on failure.
319eefe2a2SStefan Roese */
scan_padding_bytes(void * buf,int len)329eefe2a2SStefan Roese static int scan_padding_bytes(void *buf, int len)
339eefe2a2SStefan Roese {
349eefe2a2SStefan Roese int pad_len = 0, max_pad_len = min_t(int, UBIFS_PAD_NODE_SZ, len);
359eefe2a2SStefan Roese uint8_t *p = buf;
369eefe2a2SStefan Roese
379eefe2a2SStefan Roese dbg_scan("not a node");
389eefe2a2SStefan Roese
399eefe2a2SStefan Roese while (pad_len < max_pad_len && *p++ == UBIFS_PADDING_BYTE)
409eefe2a2SStefan Roese pad_len += 1;
419eefe2a2SStefan Roese
429eefe2a2SStefan Roese if (!pad_len || (pad_len & 7))
439eefe2a2SStefan Roese return SCANNED_GARBAGE;
449eefe2a2SStefan Roese
459eefe2a2SStefan Roese dbg_scan("%d padding bytes", pad_len);
469eefe2a2SStefan Roese
479eefe2a2SStefan Roese return pad_len;
489eefe2a2SStefan Roese }
499eefe2a2SStefan Roese
509eefe2a2SStefan Roese /**
519eefe2a2SStefan Roese * ubifs_scan_a_node - scan for a node or padding.
529eefe2a2SStefan Roese * @c: UBIFS file-system description object
539eefe2a2SStefan Roese * @buf: buffer to scan
549eefe2a2SStefan Roese * @len: length of buffer
559eefe2a2SStefan Roese * @lnum: logical eraseblock number
569eefe2a2SStefan Roese * @offs: offset within the logical eraseblock
579eefe2a2SStefan Roese * @quiet: print no messages
589eefe2a2SStefan Roese *
599eefe2a2SStefan Roese * This function returns a scanning code to indicate what was scanned.
609eefe2a2SStefan Roese */
ubifs_scan_a_node(const struct ubifs_info * c,void * buf,int len,int lnum,int offs,int quiet)619eefe2a2SStefan Roese int ubifs_scan_a_node(const struct ubifs_info *c, void *buf, int len, int lnum,
629eefe2a2SStefan Roese int offs, int quiet)
639eefe2a2SStefan Roese {
649eefe2a2SStefan Roese struct ubifs_ch *ch = buf;
659eefe2a2SStefan Roese uint32_t magic;
669eefe2a2SStefan Roese
679eefe2a2SStefan Roese magic = le32_to_cpu(ch->magic);
689eefe2a2SStefan Roese
699eefe2a2SStefan Roese if (magic == 0xFFFFFFFF) {
70ff94bc40SHeiko Schocher dbg_scan("hit empty space at LEB %d:%d", lnum, offs);
719eefe2a2SStefan Roese return SCANNED_EMPTY_SPACE;
729eefe2a2SStefan Roese }
739eefe2a2SStefan Roese
749eefe2a2SStefan Roese if (magic != UBIFS_NODE_MAGIC)
759eefe2a2SStefan Roese return scan_padding_bytes(buf, len);
769eefe2a2SStefan Roese
779eefe2a2SStefan Roese if (len < UBIFS_CH_SZ)
789eefe2a2SStefan Roese return SCANNED_GARBAGE;
799eefe2a2SStefan Roese
80ff94bc40SHeiko Schocher dbg_scan("scanning %s at LEB %d:%d",
81ff94bc40SHeiko Schocher dbg_ntype(ch->node_type), lnum, offs);
829eefe2a2SStefan Roese
839eefe2a2SStefan Roese if (ubifs_check_node(c, buf, lnum, offs, quiet, 1))
849eefe2a2SStefan Roese return SCANNED_A_CORRUPT_NODE;
859eefe2a2SStefan Roese
869eefe2a2SStefan Roese if (ch->node_type == UBIFS_PAD_NODE) {
879eefe2a2SStefan Roese struct ubifs_pad_node *pad = buf;
889eefe2a2SStefan Roese int pad_len = le32_to_cpu(pad->pad_len);
899eefe2a2SStefan Roese int node_len = le32_to_cpu(ch->len);
909eefe2a2SStefan Roese
919eefe2a2SStefan Roese /* Validate the padding node */
929eefe2a2SStefan Roese if (pad_len < 0 ||
939eefe2a2SStefan Roese offs + node_len + pad_len > c->leb_size) {
949eefe2a2SStefan Roese if (!quiet) {
950195a7bbSHeiko Schocher ubifs_err(c, "bad pad node at LEB %d:%d",
969eefe2a2SStefan Roese lnum, offs);
97ff94bc40SHeiko Schocher ubifs_dump_node(c, pad);
989eefe2a2SStefan Roese }
999eefe2a2SStefan Roese return SCANNED_A_BAD_PAD_NODE;
1009eefe2a2SStefan Roese }
1019eefe2a2SStefan Roese
1029eefe2a2SStefan Roese /* Make the node pads to 8-byte boundary */
1039eefe2a2SStefan Roese if ((node_len + pad_len) & 7) {
104ff94bc40SHeiko Schocher if (!quiet)
1050195a7bbSHeiko Schocher ubifs_err(c, "bad padding length %d - %d",
1069eefe2a2SStefan Roese offs, offs + node_len + pad_len);
1079eefe2a2SStefan Roese return SCANNED_A_BAD_PAD_NODE;
1089eefe2a2SStefan Roese }
1099eefe2a2SStefan Roese
110ff94bc40SHeiko Schocher dbg_scan("%d bytes padded at LEB %d:%d, offset now %d", pad_len,
111ff94bc40SHeiko Schocher lnum, offs, ALIGN(offs + node_len + pad_len, 8));
1129eefe2a2SStefan Roese
1139eefe2a2SStefan Roese return node_len + pad_len;
1149eefe2a2SStefan Roese }
1159eefe2a2SStefan Roese
1169eefe2a2SStefan Roese return SCANNED_A_NODE;
1179eefe2a2SStefan Roese }
1189eefe2a2SStefan Roese
1199eefe2a2SStefan Roese /**
1209eefe2a2SStefan Roese * ubifs_start_scan - create LEB scanning information at start of scan.
1219eefe2a2SStefan Roese * @c: UBIFS file-system description object
1229eefe2a2SStefan Roese * @lnum: logical eraseblock number
1239eefe2a2SStefan Roese * @offs: offset to start at (usually zero)
1249eefe2a2SStefan Roese * @sbuf: scan buffer (must be c->leb_size)
1259eefe2a2SStefan Roese *
1260195a7bbSHeiko Schocher * This function returns the scanned information on success and a negative error
1270195a7bbSHeiko Schocher * code on failure.
1289eefe2a2SStefan Roese */
ubifs_start_scan(const struct ubifs_info * c,int lnum,int offs,void * sbuf)1299eefe2a2SStefan Roese struct ubifs_scan_leb *ubifs_start_scan(const struct ubifs_info *c, int lnum,
1309eefe2a2SStefan Roese int offs, void *sbuf)
1319eefe2a2SStefan Roese {
1329eefe2a2SStefan Roese struct ubifs_scan_leb *sleb;
1339eefe2a2SStefan Roese int err;
1349eefe2a2SStefan Roese
1359eefe2a2SStefan Roese dbg_scan("scan LEB %d:%d", lnum, offs);
1369eefe2a2SStefan Roese
1379eefe2a2SStefan Roese sleb = kzalloc(sizeof(struct ubifs_scan_leb), GFP_NOFS);
1389eefe2a2SStefan Roese if (!sleb)
1399eefe2a2SStefan Roese return ERR_PTR(-ENOMEM);
1409eefe2a2SStefan Roese
1419eefe2a2SStefan Roese sleb->lnum = lnum;
1429eefe2a2SStefan Roese INIT_LIST_HEAD(&sleb->nodes);
1439eefe2a2SStefan Roese sleb->buf = sbuf;
1449eefe2a2SStefan Roese
145ff94bc40SHeiko Schocher err = ubifs_leb_read(c, lnum, sbuf + offs, offs, c->leb_size - offs, 0);
1469eefe2a2SStefan Roese if (err && err != -EBADMSG) {
1470195a7bbSHeiko Schocher ubifs_err(c, "cannot read %d bytes from LEB %d:%d, error %d",
148ff94bc40SHeiko Schocher c->leb_size - offs, lnum, offs, err);
1499eefe2a2SStefan Roese kfree(sleb);
1509eefe2a2SStefan Roese return ERR_PTR(err);
1519eefe2a2SStefan Roese }
1529eefe2a2SStefan Roese
1530195a7bbSHeiko Schocher /*
1540195a7bbSHeiko Schocher * Note, we ignore integrity errors (EBASMSG) because all the nodes are
1550195a7bbSHeiko Schocher * protected by CRC checksums.
1560195a7bbSHeiko Schocher */
1579eefe2a2SStefan Roese return sleb;
1589eefe2a2SStefan Roese }
1599eefe2a2SStefan Roese
1609eefe2a2SStefan Roese /**
1619eefe2a2SStefan Roese * ubifs_end_scan - update LEB scanning information at end of scan.
1629eefe2a2SStefan Roese * @c: UBIFS file-system description object
1639eefe2a2SStefan Roese * @sleb: scanning information
1649eefe2a2SStefan Roese * @lnum: logical eraseblock number
1659eefe2a2SStefan Roese * @offs: offset to start at (usually zero)
1669eefe2a2SStefan Roese */
ubifs_end_scan(const struct ubifs_info * c,struct ubifs_scan_leb * sleb,int lnum,int offs)1679eefe2a2SStefan Roese void ubifs_end_scan(const struct ubifs_info *c, struct ubifs_scan_leb *sleb,
1689eefe2a2SStefan Roese int lnum, int offs)
1699eefe2a2SStefan Roese {
1709eefe2a2SStefan Roese lnum = lnum;
1719eefe2a2SStefan Roese dbg_scan("stop scanning LEB %d at offset %d", lnum, offs);
1729eefe2a2SStefan Roese ubifs_assert(offs % c->min_io_size == 0);
1739eefe2a2SStefan Roese
1749eefe2a2SStefan Roese sleb->endpt = ALIGN(offs, c->min_io_size);
1759eefe2a2SStefan Roese }
1769eefe2a2SStefan Roese
1779eefe2a2SStefan Roese /**
1789eefe2a2SStefan Roese * ubifs_add_snod - add a scanned node to LEB scanning information.
1799eefe2a2SStefan Roese * @c: UBIFS file-system description object
1809eefe2a2SStefan Roese * @sleb: scanning information
1819eefe2a2SStefan Roese * @buf: buffer containing node
1829eefe2a2SStefan Roese * @offs: offset of node on flash
1839eefe2a2SStefan Roese *
1849eefe2a2SStefan Roese * This function returns %0 on success and a negative error code on failure.
1859eefe2a2SStefan Roese */
ubifs_add_snod(const struct ubifs_info * c,struct ubifs_scan_leb * sleb,void * buf,int offs)1869eefe2a2SStefan Roese int ubifs_add_snod(const struct ubifs_info *c, struct ubifs_scan_leb *sleb,
1879eefe2a2SStefan Roese void *buf, int offs)
1889eefe2a2SStefan Roese {
1899eefe2a2SStefan Roese struct ubifs_ch *ch = buf;
1909eefe2a2SStefan Roese struct ubifs_ino_node *ino = buf;
1919eefe2a2SStefan Roese struct ubifs_scan_node *snod;
1929eefe2a2SStefan Roese
193ff94bc40SHeiko Schocher snod = kmalloc(sizeof(struct ubifs_scan_node), GFP_NOFS);
1949eefe2a2SStefan Roese if (!snod)
1959eefe2a2SStefan Roese return -ENOMEM;
1969eefe2a2SStefan Roese
1979eefe2a2SStefan Roese snod->sqnum = le64_to_cpu(ch->sqnum);
1989eefe2a2SStefan Roese snod->type = ch->node_type;
1999eefe2a2SStefan Roese snod->offs = offs;
2009eefe2a2SStefan Roese snod->len = le32_to_cpu(ch->len);
2019eefe2a2SStefan Roese snod->node = buf;
2029eefe2a2SStefan Roese
2039eefe2a2SStefan Roese switch (ch->node_type) {
2049eefe2a2SStefan Roese case UBIFS_INO_NODE:
2059eefe2a2SStefan Roese case UBIFS_DENT_NODE:
2069eefe2a2SStefan Roese case UBIFS_XENT_NODE:
2079eefe2a2SStefan Roese case UBIFS_DATA_NODE:
2089eefe2a2SStefan Roese /*
2099eefe2a2SStefan Roese * The key is in the same place in all keyed
2109eefe2a2SStefan Roese * nodes.
2119eefe2a2SStefan Roese */
2129eefe2a2SStefan Roese key_read(c, &ino->key, &snod->key);
2139eefe2a2SStefan Roese break;
214ff94bc40SHeiko Schocher default:
215ff94bc40SHeiko Schocher invalid_key_init(c, &snod->key);
216ff94bc40SHeiko Schocher break;
2179eefe2a2SStefan Roese }
2189eefe2a2SStefan Roese list_add_tail(&snod->list, &sleb->nodes);
2199eefe2a2SStefan Roese sleb->nodes_cnt += 1;
2209eefe2a2SStefan Roese return 0;
2219eefe2a2SStefan Roese }
2229eefe2a2SStefan Roese
2239eefe2a2SStefan Roese /**
2249eefe2a2SStefan Roese * ubifs_scanned_corruption - print information after UBIFS scanned corruption.
2259eefe2a2SStefan Roese * @c: UBIFS file-system description object
2269eefe2a2SStefan Roese * @lnum: LEB number of corruption
2279eefe2a2SStefan Roese * @offs: offset of corruption
2289eefe2a2SStefan Roese * @buf: buffer containing corruption
2299eefe2a2SStefan Roese */
ubifs_scanned_corruption(const struct ubifs_info * c,int lnum,int offs,void * buf)2309eefe2a2SStefan Roese void ubifs_scanned_corruption(const struct ubifs_info *c, int lnum, int offs,
2319eefe2a2SStefan Roese void *buf)
2329eefe2a2SStefan Roese {
2339eefe2a2SStefan Roese int len;
2349eefe2a2SStefan Roese
2350195a7bbSHeiko Schocher ubifs_err(c, "corruption at LEB %d:%d", lnum, offs);
2369eefe2a2SStefan Roese len = c->leb_size - offs;
237ff94bc40SHeiko Schocher if (len > 8192)
238ff94bc40SHeiko Schocher len = 8192;
2390195a7bbSHeiko Schocher ubifs_err(c, "first %d bytes from LEB %d:%d", len, lnum, offs);
240*f8c987f8SAlexey Brodkin print_hex_dump("", DUMP_PREFIX_OFFSET, 32, 4, buf, len, 1);
2419eefe2a2SStefan Roese }
2429eefe2a2SStefan Roese
2439eefe2a2SStefan Roese /**
2449eefe2a2SStefan Roese * ubifs_scan - scan a logical eraseblock.
2459eefe2a2SStefan Roese * @c: UBIFS file-system description object
2469eefe2a2SStefan Roese * @lnum: logical eraseblock number
2479eefe2a2SStefan Roese * @offs: offset to start at (usually zero)
248ff94bc40SHeiko Schocher * @sbuf: scan buffer (must be of @c->leb_size bytes in size)
249ff94bc40SHeiko Schocher * @quiet: print no messages
2509eefe2a2SStefan Roese *
2519eefe2a2SStefan Roese * This function scans LEB number @lnum and returns complete information about
2520195a7bbSHeiko Schocher * its contents. Returns the scanned information in case of success and,
253ff94bc40SHeiko Schocher * %-EUCLEAN if the LEB neads recovery, and other negative error codes in case
254ff94bc40SHeiko Schocher * of failure.
255ff94bc40SHeiko Schocher *
256ff94bc40SHeiko Schocher * If @quiet is non-zero, this function does not print large and scary
257ff94bc40SHeiko Schocher * error messages and flash dumps in case of errors.
2589eefe2a2SStefan Roese */
ubifs_scan(const struct ubifs_info * c,int lnum,int offs,void * sbuf,int quiet)2599eefe2a2SStefan Roese struct ubifs_scan_leb *ubifs_scan(const struct ubifs_info *c, int lnum,
260ff94bc40SHeiko Schocher int offs, void *sbuf, int quiet)
2619eefe2a2SStefan Roese {
2629eefe2a2SStefan Roese void *buf = sbuf + offs;
2639eefe2a2SStefan Roese int err, len = c->leb_size - offs;
2649eefe2a2SStefan Roese struct ubifs_scan_leb *sleb;
2659eefe2a2SStefan Roese
2669eefe2a2SStefan Roese sleb = ubifs_start_scan(c, lnum, offs, sbuf);
2679eefe2a2SStefan Roese if (IS_ERR(sleb))
2689eefe2a2SStefan Roese return sleb;
2699eefe2a2SStefan Roese
2709eefe2a2SStefan Roese while (len >= 8) {
2719eefe2a2SStefan Roese struct ubifs_ch *ch = buf;
2729eefe2a2SStefan Roese int node_len, ret;
2739eefe2a2SStefan Roese
2749eefe2a2SStefan Roese dbg_scan("look at LEB %d:%d (%d bytes left)",
2759eefe2a2SStefan Roese lnum, offs, len);
2769eefe2a2SStefan Roese
2779eefe2a2SStefan Roese cond_resched();
2789eefe2a2SStefan Roese
279ff94bc40SHeiko Schocher ret = ubifs_scan_a_node(c, buf, len, lnum, offs, quiet);
2809eefe2a2SStefan Roese if (ret > 0) {
2819eefe2a2SStefan Roese /* Padding bytes or a valid padding node */
2829eefe2a2SStefan Roese offs += ret;
2839eefe2a2SStefan Roese buf += ret;
2849eefe2a2SStefan Roese len -= ret;
2859eefe2a2SStefan Roese continue;
2869eefe2a2SStefan Roese }
2879eefe2a2SStefan Roese
2889eefe2a2SStefan Roese if (ret == SCANNED_EMPTY_SPACE)
2899eefe2a2SStefan Roese /* Empty space is checked later */
2909eefe2a2SStefan Roese break;
2919eefe2a2SStefan Roese
2929eefe2a2SStefan Roese switch (ret) {
2939eefe2a2SStefan Roese case SCANNED_GARBAGE:
2940195a7bbSHeiko Schocher ubifs_err(c, "garbage");
2959eefe2a2SStefan Roese goto corrupted;
2969eefe2a2SStefan Roese case SCANNED_A_NODE:
2979eefe2a2SStefan Roese break;
2989eefe2a2SStefan Roese case SCANNED_A_CORRUPT_NODE:
2999eefe2a2SStefan Roese case SCANNED_A_BAD_PAD_NODE:
3000195a7bbSHeiko Schocher ubifs_err(c, "bad node");
3019eefe2a2SStefan Roese goto corrupted;
3029eefe2a2SStefan Roese default:
3030195a7bbSHeiko Schocher ubifs_err(c, "unknown");
304ff94bc40SHeiko Schocher err = -EINVAL;
305ff94bc40SHeiko Schocher goto error;
3069eefe2a2SStefan Roese }
3079eefe2a2SStefan Roese
3089eefe2a2SStefan Roese err = ubifs_add_snod(c, sleb, buf, offs);
3099eefe2a2SStefan Roese if (err)
3109eefe2a2SStefan Roese goto error;
3119eefe2a2SStefan Roese
3129eefe2a2SStefan Roese node_len = ALIGN(le32_to_cpu(ch->len), 8);
3139eefe2a2SStefan Roese offs += node_len;
3149eefe2a2SStefan Roese buf += node_len;
3159eefe2a2SStefan Roese len -= node_len;
3169eefe2a2SStefan Roese }
3179eefe2a2SStefan Roese
318ff94bc40SHeiko Schocher if (offs % c->min_io_size) {
319ff94bc40SHeiko Schocher if (!quiet)
3200195a7bbSHeiko Schocher ubifs_err(c, "empty space starts at non-aligned offset %d",
321ff94bc40SHeiko Schocher offs);
3229eefe2a2SStefan Roese goto corrupted;
323ff94bc40SHeiko Schocher }
3249eefe2a2SStefan Roese
3259eefe2a2SStefan Roese ubifs_end_scan(c, sleb, lnum, offs);
3269eefe2a2SStefan Roese
3279eefe2a2SStefan Roese for (; len > 4; offs += 4, buf = buf + 4, len -= 4)
3289eefe2a2SStefan Roese if (*(uint32_t *)buf != 0xffffffff)
3299eefe2a2SStefan Roese break;
3309eefe2a2SStefan Roese for (; len; offs++, buf++, len--)
3319eefe2a2SStefan Roese if (*(uint8_t *)buf != 0xff) {
332ff94bc40SHeiko Schocher if (!quiet)
3330195a7bbSHeiko Schocher ubifs_err(c, "corrupt empty space at LEB %d:%d",
3349eefe2a2SStefan Roese lnum, offs);
3359eefe2a2SStefan Roese goto corrupted;
3369eefe2a2SStefan Roese }
3379eefe2a2SStefan Roese
3389eefe2a2SStefan Roese return sleb;
3399eefe2a2SStefan Roese
3409eefe2a2SStefan Roese corrupted:
341ff94bc40SHeiko Schocher if (!quiet) {
3429eefe2a2SStefan Roese ubifs_scanned_corruption(c, lnum, offs, buf);
3430195a7bbSHeiko Schocher ubifs_err(c, "LEB %d scanning failed", lnum);
344ff94bc40SHeiko Schocher }
345ff94bc40SHeiko Schocher err = -EUCLEAN;
346ff94bc40SHeiko Schocher ubifs_scan_destroy(sleb);
347ff94bc40SHeiko Schocher return ERR_PTR(err);
348ff94bc40SHeiko Schocher
349ff94bc40SHeiko Schocher error:
3500195a7bbSHeiko Schocher ubifs_err(c, "LEB %d scanning failed, error %d", lnum, err);
3519eefe2a2SStefan Roese ubifs_scan_destroy(sleb);
3529eefe2a2SStefan Roese return ERR_PTR(err);
3539eefe2a2SStefan Roese }
3549eefe2a2SStefan Roese
3559eefe2a2SStefan Roese /**
3569eefe2a2SStefan Roese * ubifs_scan_destroy - destroy LEB scanning information.
3579eefe2a2SStefan Roese * @sleb: scanning information to free
3589eefe2a2SStefan Roese */
ubifs_scan_destroy(struct ubifs_scan_leb * sleb)3599eefe2a2SStefan Roese void ubifs_scan_destroy(struct ubifs_scan_leb *sleb)
3609eefe2a2SStefan Roese {
3619eefe2a2SStefan Roese struct ubifs_scan_node *node;
3629eefe2a2SStefan Roese struct list_head *head;
3639eefe2a2SStefan Roese
3649eefe2a2SStefan Roese head = &sleb->nodes;
3659eefe2a2SStefan Roese while (!list_empty(head)) {
3669eefe2a2SStefan Roese node = list_entry(head->next, struct ubifs_scan_node, list);
3679eefe2a2SStefan Roese list_del(&node->list);
3689eefe2a2SStefan Roese kfree(node);
3699eefe2a2SStefan Roese }
3709eefe2a2SStefan Roese kfree(sleb);
3719eefe2a2SStefan Roese }
372