Linux 4.13.3
Greg KH
maintainerI'm announcing the release of the 4.13.3 kernel.
All users of the 4.13 kernel series must upgrade.
The updated 4.13.y git tree can be found at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git linux-4.13.y
and can be browsed at the normal kernel.org git web browser:
http://git.kernel.org/?p=linux/kernel/git/stable/linux-stable.git;a=summary
thanks,
greg k-h
------------
Documentation/ABI/testing/sysfs-bus-thunderbolt | 2 Makefile | 2 arch/x86/include/asm/elf.h | 5 arch/x86/include/asm/page_64.h | 4 arch/x86/kernel/cpu/mcheck/mce.c | 43 ++++ arch/x86/kernel/process_64.c | 236 +++++++++++++----------- drivers/md/raid1.c | 19 + drivers/md/raid10.c | 35 +++ drivers/md/raid5.c | 4 drivers/net/ethernet/freescale/gianfar.c | 2 drivers/nvdimm/btt.c | 2 drivers/nvdimm/bus.c | 17 - drivers/thunderbolt/switch.c | 20 +- drivers/vhost/net.c | 7 fs/f2fs/recovery.c | 4 fs/fuse/dev.c | 13 - fs/fuse/file.c | 3 fs/inode.c | 1 fs/internal.h | 1 fs/overlayfs/inode.c | 11 - fs/xfs/libxfs/xfs_bmap.c | 2 fs/xfs/libxfs/xfs_bmap_btree.c | 1 fs/xfs/libxfs/xfs_btree.c | 27 +- fs/xfs/libxfs/xfs_btree.h | 3 fs/xfs/libxfs/xfs_ialloc.c | 57 ++--- fs/xfs/libxfs/xfs_inode_fork.c | 9 fs/xfs/xfs_aops.c | 71 ++++--- fs/xfs/xfs_bmap_util.c | 93 +++++++-- fs/xfs/xfs_buf_item.c | 137 +++++++++---- fs/xfs/xfs_buf_item.h | 5 fs/xfs/xfs_icache.c | 10 - fs/xfs/xfs_inode.c | 23 +- fs/xfs/xfs_inode_item.c | 47 ++++ fs/xfs/xfs_ioctl.c | 41 ++-- fs/xfs/xfs_iops.c | 2 fs/xfs/xfs_log.c | 33 ++- fs/xfs/xfs_log_recover.c | 159 ++++++++++------ fs/xfs/xfs_super.c | 2 fs/xfs/xfs_trace.h | 1 fs/xfs/xfs_trans.h | 14 + fs/xfs/xfs_trans_ail.c | 3 fs/xfs/xfs_trans_buf.c | 79 ++++---- fs/xfs/xfs_trans_priv.h | 31 +++ include/linux/fs.h | 1 include/linux/mm_inline.h | 6 include/linux/skbuff.h | 2 include/net/inet_frag.h | 35 --- lib/idr.c | 2 mm/memory-failure.c | 2 net/core/skbuff.c | 9 net/ieee802154/6lowpan/reassembly.c | 11 - net/ipv4/inet_fragment.c | 4 net/ipv4/ip_fragment.c | 12 - net/ipv4/ip_tunnel.c | 4 net/ipv4/tcp_ipv4.c | 6 net/ipv4/udp.c | 5 net/ipv6/ip6_fib.c | 25 +- net/ipv6/ip6_gre.c | 4 net/ipv6/netfilter/nf_conntrack_reasm.c | 12 - net/ipv6/reassembly.c | 12 - net/ipv6/tcp_ipv6.c | 6 net/sctp/ulpqueue.c | 3 62 files changed, 928 insertions(+), 514 deletions(-)
Amir Goldstein (2):
ovl: fix false positive ESTALE on lookup
xfs: fix incorrect log_flushed on fsync
Andy Lutomirski (3):
x86/fsgsbase/64: Fully initialize FS and GS state in start_thread_common x86/fsgsbase/64: Report FSBASE and GSBASE correctly in core dumps x86/switch_to/64: Rewrite FS/GS switching yet again to fix AMD CPUs
Bernat, Yehezkel (3):
thunderbolt: Remove superfluous check
thunderbolt: Make key root-only accessible
thunderbolt: Allow clearing the key
Brian Foster (13):
xfs: fix recovery failure when log record header wraps log end
xfs: always verify the log tail during recovery
xfs: fix log recovery corruption error due to tail overwrite
xfs: handle -EFSCORRUPTED during head/tail verification
xfs: open-code xfs_buf_item_dirty()
xfs: remove unnecessary dirty bli format check for ordered bufs
xfs: ordered buffer log items are never formatted
xfs: refactor buffer logging into buffer dirtying helper
xfs: don't log dirty ranges for ordered buffers
xfs: skip bmbt block ino validation during owner change
xfs: move bmbt owner change to last step of extent swap
xfs: disallow marking previously dirty buffers as ordered
xfs: relog dirty buffers during swapext bmbt owner change
Carlos Maiolino (3):
xfs: Add infrastructure needed for error propagation during buffer IO failure
xfs: Properly retry failed inode items in case of error during buffer writeback
xfs: stop searching for free slots in an inode chunk when there are none
Christoph Hellwig (3):
xfs: disable per-inode DAX flag
xfs: don't set v3 xflags for v2 inodes
xfs: open code end_buffer_async_write in xfs_finish_page_writeback
Christophe Jaillet (1):
libnvdimm, btt: check memory allocation failure
Claudiu Manoil (1):
gianfar: Fix Tx flow control deactivation
Dan Williams (1):
libnvdimm: fix integer overflow static analysis warning
Darrick J. Wong (2):
xfs: evict all inodes involved with log redo item
xfs: fix compiler warnings
Eric Biggers (1):
idr: remove WARN_ON_ONCE() when trying to replace negative ID
Eric Dumazet (2):
ipv6: fix typo in fib6_net_exit()
tcp: fix a request socket leak
Eric Sandeen (2):
xfs: write unmount record for ro mounts
xfs: toggle readonly state around xfs_log_mount_finish
Greg Kroah-Hartman (1):
Linux 4.13.3
Haishuang Yan (1):
ip_tunnel: fix setting ttl and tos value in collect_md mode
Jaegeuk Kim (2):
f2fs: let fill_super handle roll-forward errors
f2fs: check hot_data for roll-forward recovery
Jason Wang (1):
vhost_net: correctly check tx avail during rx busy polling
Jesper Dangaard Brouer (2):
Revert "net: use lib/percpu_counter API for fragmentation mem accounting" Revert "net: fix percpu memory leaks"
Marcelo Ricardo Leitner (1):
sctp: fix missing wake ups in some situations
Miklos Szeredi (1):
fuse: allow server to run in different pid_ns
Omar Sandoval (1):
xfs: check for race with xfs_reclaim_inode() in xfs_ifree_cluster()
Pan Bian (1):
xfs: use kmem_free to free return value of kmem_zalloc
Paolo Abeni (1):
udp: drop head states only when all skb references are gone
Sabrina Dubroca (1):
ipv6: fix memory leak with multiple tables during netns destruction
Shaohua Li (1):
md/raid1/10: reset bio allocated from mempool
Song Liu (1):
md/raid5: release/flush io in raid5_do_work()
Tony Luck (1):
x86/mm, mm/hwpoison: Clear PRESENT bit for kernel 1:1 mappings of poison pages
Xin Long (1):
ip6_gre: update mtu properly in ip6gre_err
Greg KH
maintainerDocumentation/ABI/testing/sysfs-bus-thunderbolt +2 -0
@@ -45,6 +45,8 @@ Contact: [email protected] Description: When a devices supports Thunderbolt secure connect it will have this attribute. Writing 32 byte hex string changes authorization to use the secure connection method instead. + Writing an empty string clears the key and regular connection + method can be used again. What: /sys/bus/thunderbolt/devices/.../device Date: Sep 2017
Makefile +1 -1
@@ -1,6 +1,6 @@ VERSION = 4 PATCHLEVEL = 13 -SUBLEVEL = 2 +SUBLEVEL = 3 EXTRAVERSION = NAME = Fearless Coyote
arch/x86/include/asm/elf.h +3 -2
@@ -204,6 +204,7 @@ void set_personality_ia32(bool);#define ELF_CORE_COPY_REGS (pr_reg, regs) \ do { \ + unsigned long base; \ unsigned v; \ (pr_reg)[0] = (regs)->r15; \ (pr_reg)[1] = (regs)->r14; \
@@ -226,8 +227,8 @@ do { \ (pr_reg)[18 ] = (regs)->flags; \ (pr_reg)[19 ] = (regs)->sp; \ (pr_reg)[20 ] = (regs)->ss; \ - (pr_reg)[21 ] = current->thread.fsbase; \ - (pr_reg)[22 ] = current->thread.gsbase; \ +rdmsrl (MSR_FS_BASE , base); (pr_reg)[21 ] = base; \ +rdmsrl (MSR_KERNEL_GS_BASE , base); (pr_reg)[22 ] = base; \ asm("movl %%ds,%0" :"=r" (v)); (pr_reg)[23 ] = v; \ asm("movl %%es,%0" :"=r" (v)); (pr_reg)[24 ] = v; \ asm("movl %%fs,%0" :"=r" (v)); (pr_reg)[25 ] = v; \
arch/x86/include/asm/page_64.h +4 -0
@@ -51,6 +51,10 @@ static inline void clear_page(void *page)void copy_page (void *to,void *from); +#ifdef CONFIG_X86_MCE +#define arch_unmap_kpfn arch_unmap_kpfn +#endif +#endif /* !__ASSEMBLY__ */ #ifdef CONFIG_X86_VSYSCALL_EMULATION
arch/x86/kernel/cpu/mcheck/mce.c +43 -0
55 lines not on this page · raw message
arch/x86/kernel/process_64.c +131 -105
270 lines not on this page · raw message
drivers/md/raid1.c +18 -1
@@ -2564,6 +2564,23 @@ static int init_resync(struct r1conf *conf)return 0 ; } +static struct r1bio *raid1_alloc_init_r1buf (struct r1conf *conf) +{ +struct r1bio *r1bio =mempool_alloc (conf->r1buf_pool,GFP_NOIO ); +struct resync_pages *rps; +struct bio *bio; +int i; + +for (i = conf->poolinfo->raid_disks; i--; ) { + bio = r1bio->bios[i]; + rps = bio->bi_private; +bio_reset (bio); + bio->bi_private = rps; + } + r1bio->master_bio =NULL ; +return r1bio; +} +/* * perform a "sync" on one "block" *
@@ -2649,7 +2666,7 @@ static sector_t raid1_sync_request(struct mddev *mddev, sector_t sector_nr,bitmap_cond_end_sync (mddev->bitmap, sector_nr,mddev_is_clustered (mddev) && (sector_nr +2 *RESYNC_SECTORS > conf->cluster_sync_high)); - r1_bio =mempool_alloc (conf->r1buf_pool,GFP_NOIO ); + r1_bio =raid1_alloc_init_r1buf (conf);raise_barrier (conf, sector_nr);
drivers/md/raid10.c +32 -3
@@ -2798,6 +2798,35 @@ static int init_resync(struct r10conf *conf)return 0 ; } +static struct r10bio *raid10_alloc_init_r10buf (struct r10conf *conf) +{ +struct r10bio *r10bio =mempool_alloc (conf->r10buf_pool,GFP_NOIO ); +struct rsync_pages *rp; +struct bio *bio; +int nalloc; +int i; + +if (test_bit (MD_RECOVERY_SYNC , &conf->mddev->recovery) || +test_bit (MD_RECOVERY_RESHAPE , &conf->mddev->recovery)) + nalloc = conf->copies;/* resync */ +else + nalloc =2 ;/* recovery */ + +for (i =0 ; i < nalloc; i++) { + bio = r10bio->devs[i].bio; + rp = bio->bi_private; +bio_reset (bio); + bio->bi_private = rp; + bio = r10bio->devs[i].repl_bio; +if (bio) { + rp = bio->bi_private; +bio_reset (bio); + bio->bi_private = rp; + } + } +return r10bio; +} +/* * perform a "sync" on one "block" *
@@ -3027,7 +3056,7 @@ static sector_t raid10_sync_request(struct mddev *mddev, sector_t sector_nr,atomic_inc (&mreplace->nr_pending);rcu_read_unlock (); - r10_bio =mempool_alloc (conf->r10buf_pool,GFP_NOIO ); + r10_bio =raid10_alloc_init_r10buf (conf); r10_bio->state =0 ;raise_barrier (conf, rb2 !=NULL );atomic_set (&r10_bio->remaining,0 );
@@ -3236,7 +3265,7 @@ static sector_t raid10_sync_request(struct mddev *mddev, sector_t sector_nr, }if (sync_blocks < max_sync) max_sync = sync_blocks; - r10_bio =mempool_alloc (conf->r10buf_pool,GFP_NOIO ); + r10_bio =raid10_alloc_init_r10buf (conf); r10_bio->state =0 ; r10_bio->mddev = mddev;
@@ -4360,7 +4389,7 @@ static sector_t reshape_request(struct mddev *mddev, sector_t sector_nr, read_more:/* Now schedule reads for blocks from sector_nr to last */ - r10_bio =mempool_alloc (conf->r10buf_pool,GFP_NOIO ); + r10_bio =raid10_alloc_init_r10buf (conf); r10_bio->state =0 ;raise_barrier (conf, sectors_done !=0 );atomic_set (&r10_bio->remaining,0 );
drivers/md/raid5.c +4 -0
@@ -6235,6 +6235,10 @@ static void raid5_do_work(struct work_struct *work)spin_unlock_irq (&conf->device_lock); +flush_deferred_bios (conf); + +r5l_flush_stripe_to_raid (conf->log); +async_tx_issue_pending_all ();blk_finish_plug (&plug);
drivers/net/ethernet/freescale/gianfar.c +1 -1
@@ -3687,7 +3687,7 @@ static noinline void gfar_update_link_state(struct gfar_private *priv)u32 tempval1 =gfar_read (®s->maccfg1);u32 tempval =gfar_read (®s->maccfg2);u32 ecntrl =gfar_read (®s->ecntrl); -u32 tx_flow_oldval = (tempval &MACCFG1_TX_FLOW ); +u32 tx_flow_oldval = (tempval1 &MACCFG1_TX_FLOW );if (phydev->duplex != priv->oldduplex) {if (!(phydev->duplex))
drivers/nvdimm/btt.c +2 -0
@@ -1429,6 +1429,8 @@ int nvdimm_namespace_attach_btt(struct nd_namespace_common *ndns) } btt_sb =devm_kzalloc (&nd_btt->dev,sizeof (*btt_sb),GFP_KERNEL ); +if (!btt_sb) +return -ENOMEM ;/* * If this returns < 0, that is ok as it just means there wasn't
drivers/nvdimm/bus.c +9 -8
@@ -905,19 +905,20 @@ static int __nd_ioctl(struct nvdimm_bus *nvdimm_bus, struct nvdimm *nvdimm, int read_only, unsigned int ioctl_cmd, unsigned long arg) { struct nvdimm_bus_descriptor *nd_desc = nvdimm_bus->nd_desc; -size_t buf_len =0 , in_len =0 , out_len =0 ;static char out_env[ND_CMD_MAX_ENVELOPE ];static char in_env[ND_CMD_MAX_ENVELOPE ];const struct nd_cmd_desc *desc =NULL ;unsigned int cmd =_IOC_NR (ioctl_cmd); -unsigned int func = cmd; -void __user *p = (void __user *) arg;struct device *dev = &nvdimm_bus->dev; -struct nd_cmd_pkg pkg; +void __user *p = (void __user *) arg;const char *cmd_name, *dimm_name; +u32 in_len =0 , out_len =0 ; +unsigned int func = cmd;unsigned long cmd_mask; -void *buf; +struct nd_cmd_pkg pkg;int rc, i, cmd_rc; +u64 buf_len =0 ; +void *buf;if (nvdimm) { desc =nd_cmd_dimm_desc (cmd);
@@ -977,7 +978,7 @@ static int __nd_ioctl(struct nvdimm_bus *nvdimm_bus, struct nvdimm *nvdimm,if (cmd ==ND_CMD_CALL ) { func = pkg.nd_command; -dev_dbg (dev,"%s:%s, idx: %llu, in: %zu, out: %zu, len %zu\n" , +dev_dbg (dev,"%s:%s, idx: %llu, in: %u, out: %u, len %llu\n" , __func__, dimm_name, pkg.nd_command, in_len, out_len, buf_len);
@@ -1007,9 +1008,9 @@ static int __nd_ioctl(struct nvdimm_bus *nvdimm_bus, struct nvdimm *nvdimm, out_len += out_size; } - buf_len = out_len + in_len; + buf_len = (u64 ) out_len + (u64 ) in_len;if (buf_len >ND_IOCTL_MAX_BUFLEN ) { -dev_dbg (dev,"%s:%s cmd: %s buf_len: %zu > %d\n" , __func__, +dev_dbg (dev,"%s:%s cmd: %s buf_len: %llu > %d\n" , __func__, dimm_name, cmd_name, buf_len,ND_IOCTL_MAX_BUFLEN );return -EINVAL ;
drivers/thunderbolt/switch.c +12 -8
@@ -807,11 +807,11 @@ static ssize_t key_store(struct device *dev, struct device_attribute *attr,struct tb_switch *sw =tb_to_switch (dev);u8 key[TB_SWITCH_KEY_SIZE ];ssize_t ret = count; +bool clear = false; -if (count <64 ) -return -EINVAL ; - -if (hex2bin (key, buf,sizeof (key))) +if (!strcmp (buf,"\n" )) + clear = true; +else if (hex2bin (key, buf,sizeof (key)))return -EINVAL ;if (mutex_lock_interruptible (&switch_lock))
@@ -821,15 +821,19 @@ static ssize_t key_store(struct device *dev, struct device_attribute *attr, ret = -EBUSY ; }else {kfree (sw->key); - sw->key =kmemdup (key,sizeof (key),GFP_KERNEL ); -if (!sw->key) - ret = -ENOMEM ; +if (clear) { + sw->key =NULL ; + }else { + sw->key =kmemdup (key,sizeof (key),GFP_KERNEL ); +if (!sw->key) + ret = -ENOMEM ; + } }mutex_unlock (&switch_lock);return ret; } -static DEVICE_ATTR_RW (key); +static DEVICE_ATTR(key, 0600, key_show, key_store);static ssize_t nvm_authenticate_show (struct device *dev,struct device_attribute *attr,char *buf)
drivers/vhost/net.c +6 -1
@@ -634,8 +634,13 @@ static int vhost_net_rx_peek_head_len(struct vhost_net *net, struct sock *sk)preempt_enable (); -if (vhost_enable_notify (&net->dev, vq)) +if (!vhost_vq_avail_empty (&net->dev, vq))vhost_poll_queue (&vq->poll); +else if (unlikely (vhost_enable_notify (&net->dev, vq))) { +vhost_disable_notify (&net->dev, vq); +vhost_poll_queue (&vq->poll); + } +mutex_unlock (&vq->mutex); len =peek_head_len (rvq, sk);
fs/f2fs/recovery.c +1 -3
@@ -291,7 +291,7 @@ static int check_index_in_prev_nodes(struct f2fs_sb_info *sbi,return 0 ;/* Get the previous summary */ -for (i =CURSEG_WARM_DATA ; i <=CURSEG_COLD_DATA ; i++) { +for (i =CURSEG_HOT_DATA ; i <=CURSEG_COLD_DATA ; i++) {struct curseg_info *curseg =CURSEG_I (sbi, i);if (curseg->segno == segno) { sum = curseg->sum_blk->entries[blkoff];
@@ -599,8 +599,6 @@ int recover_fsync_data(struct f2fs_sb_info *sbi, bool check_only) }clear_sbi_flag (sbi,SBI_POR_DOING ); -if (err) -set_ckpt_flags (sbi,CP_ERROR_FLAG );mutex_unlock (&sbi->cp_mutex);/* let's drop all the directory inodes for clean checkpoint */
fs/fuse/dev.c +7 -6
@@ -1222,9 +1222,6 @@ static ssize_t fuse_dev_do_read(struct fuse_dev *fud, struct file *file,struct fuse_in *in;unsigned reqsize; -if (task_active_pid_ns (current) != fc->pid_ns) -return -EIO ; - restart:spin_lock (&fiq->waitq.lock); err = -EAGAIN ;
@@ -1262,6 +1259,13 @@ static ssize_t fuse_dev_do_read(struct fuse_dev *fud, struct file *file, in = &req->in; reqsize = in->h.len; + +if (task_active_pid_ns (current) != fc->pid_ns) { +rcu_read_lock (); + in->h.pid =pid_vnr (find_pid_ns (in->h.pid, fc->pid_ns)); +rcu_read_unlock (); + } +/* If request is too large, reply with an error and restart the read */ if (nbytes < reqsize) { req->out.h.error = -EIO ;
@@ -1823,9 +1827,6 @@ static ssize_t fuse_dev_do_write(struct fuse_dev *fud,struct fuse_req *req;struct fuse_out_header oh; -if (task_active_pid_ns (current) != fc->pid_ns) -return -EIO ; -if (nbytes <sizeof (struct fuse_out_header ))return -EINVAL ;
fs/fuse/file.c +0 -3
@@ -2181,9 +2181,6 @@ static int fuse_setlk(struct file *file, struct file_lock *fl, int flock)if ((fl->fl_flags &FL_CLOSE_POSIX ) ==FL_CLOSE_POSIX )return 0 ; -if (pid && pid_nr ==0 ) -return -EOVERFLOW ; -fuse_lk_fill (&args, file, fl, opcode, pid_nr, flock, &inarg); err =fuse_simple_request (fc, &args);
fs/inode.c +1 -0
@@ -637,6 +637,7 @@ void evict_inodes(struct super_block *sb)dispose_list (&dispose); } +EXPORT_SYMBOL_GPL (evict_inodes);/** * invalidate_inodes - attempt to free all inodes on a superblock
fs/internal.h +0 -1
@@ -132,7 +132,6 @@ static inline bool atime_needs_update_rcu(const struct path *path,extern void inode_io_list_del (struct inode *inode);extern long get_nr_dirty_inodes (void ); -extern void evict_inodes (struct super_block *);extern int invalidate_inodes (struct super_block *,bool );/*
fs/overlayfs/inode.c +7 -4
@@ -576,10 +576,13 @@ static int ovl_inode_set(struct inode *inode, void *data)static bool ovl_verify_inode (struct inode *inode,struct dentry *lowerdentry,struct dentry *upperdentry) { -struct inode *lowerinode = lowerdentry ?d_inode (lowerdentry) :NULL ; - -/* Lower (origin) inode must match, even if NULL */ -if (ovl_inode_lower (inode) != lowerinode) +/* +* Allow non-NULL lower inode in ovl_inode even if lowerdentry is NULL. +* This happens when finding a copied up overlay inode for a renamed +* or hardlinked overlay dentry and lower dentry cannot be followed +* by origin because lower fs does not support file handles. +*/ +if (lowerdentry &&ovl_inode_lower (inode) !=d_inode (lowerdentry))return false;/*
fs/xfs/libxfs/xfs_bmap.c +1 -1
@@ -579,7 +579,7 @@ xfs_bmap_validate_ret(#else #define xfs_bmap_check_leaf_extents (cur, ip, whichfork) do { } while (0) -#define xfs_bmap_validate_ret (bno,len,flags,mval,onmap,nmap) +#define xfs_bmap_validate_ret (bno,len,flags,mval,onmap,nmap) do { } while (0)#endif /* DEBUG */ /*
fs/xfs/libxfs/xfs_bmap_btree.c +1 -0
@@ -858,6 +858,7 @@ xfs_bmbt_change_owner( cur =xfs_bmbt_init_cursor (ip->i_mount, tp, ip, whichfork);if (!cur)return -ENOMEM ; + cur->bc_private.b.flags |=XFS_BTCUR_BPRV_INVALID_OWNER ; error =xfs_btree_change_owner (cur, new_owner, buffer_list);xfs_btree_del_cursor (cur, error ?XFS_BTREE_ERROR :XFS_BTREE_NOERROR );
fs/xfs/libxfs/xfs_btree.c +18 -9
@@ -1791,6 +1791,7 @@ xfs_btree_lookup_get_block(/* Check the inode owner since the verifiers don't. */ if (xfs_sb_version_hascrc (&cur->bc_mp->m_sb) && + !(cur->bc_private.b.flags &XFS_BTCUR_BPRV_INVALID_OWNER ) && (cur->bc_flags &XFS_BTREE_LONG_PTRS ) &&be64_to_cpu ((*blkp)->bb_u.l.bb_owner) != cur->bc_private.b.ip->i_ino)
@@ -4451,10 +4452,15 @@ xfs_btree_block_change_owner(/* modify the owner */ block =xfs_btree_get_block (cur, level, &bp); -if (cur->bc_flags &XFS_BTREE_LONG_PTRS ) +if (cur->bc_flags &XFS_BTREE_LONG_PTRS ) { +if (block->bb_u.l.bb_owner ==cpu_to_be64 (bbcoi->new_owner)) +return 0 ; block->bb_u.l.bb_owner =cpu_to_be64 (bbcoi->new_owner); -else + }else { +if (block->bb_u.s.bb_owner ==cpu_to_be32 (bbcoi->new_owner)) +return 0 ; block->bb_u.s.bb_owner =cpu_to_be32 (bbcoi->new_owner); + }/* * If the block is a root block hosted in an inode, we might not have a
@@ -4463,16 +4469,19 @@ xfs_btree_block_change_owner(* block is formatted into the on-disk inode fork. We still change it, * though, so everything is consistent in memory. */ -if (bp) { -if (cur->bc_tp) { -xfs_trans_ordered_buf (cur->bc_tp, bp); +if (!bp) { +ASSERT (cur->bc_flags &XFS_BTREE_ROOT_IN_INODE ); +ASSERT (level == cur->bc_nlevels -1 ); +return 0 ; + } + +if (cur->bc_tp) { +if (!xfs_trans_ordered_buf (cur->bc_tp, bp)) {xfs_btree_log_block (cur, bp,XFS_BB_OWNER ); - }else { -xfs_buf_delwri_queue (bp, bbcoi->buffer_list); +return -EAGAIN ; } }else { -ASSERT (cur->bc_flags &XFS_BTREE_ROOT_IN_INODE ); -ASSERT (level == cur->bc_nlevels -1 ); +xfs_buf_delwri_queue (bp, bbcoi->buffer_list); }return 0 ;
fs/xfs/libxfs/xfs_btree.h +2 -1
@@ -233,7 +233,8 @@ typedef struct xfs_btree_curshort forksize;/* fork's inode space */ char whichfork;/* data or attr fork */ char flags;/* flags */ -#define XFS_BTCUR_BPRV_WASDEL 1/* was delayed */ +#define XFS_BTCUR_BPRV_WASDEL (1<<0)/* was delayed */ +#define XFS_BTCUR_BPRV_INVALID_OWNER (1<<1)/* for ext swap */ } b; } bc_private;/* per-btree type data */ } xfs_btree_cur_t;
fs/xfs/libxfs/xfs_ialloc.c +27 -30
95 lines not on this page · raw message
fs/xfs/libxfs/xfs_inode_fork.c +3 -6
@@ -1499,14 +1499,11 @@ xfs_iext_realloc_indirect(xfs_ifork_t *ifp,/* inode fork pointer */ int new_size) /* new indirection array size */ { - int nlists; /* number of irec's (ex lists) */ -int size;/* current indirection array size */ - ASSERT(ifp->if_flags & XFS_IFEXTIREC); - nlists = ifp->if_real_bytes /XFS_IEXT_BUFSZ ; - size = nlists *sizeof (xfs_ext_irec_t);ASSERT (ifp->if_real_bytes); -ASSERT ((new_size >=0 ) && (new_size != size)); +ASSERT ((new_size >=0 ) && + (new_size != ((ifp->if_real_bytes /XFS_IEXT_BUFSZ ) * +sizeof (xfs_ext_irec_t))));if (new_size ==0 ) {xfs_iext_destroy (ifp); }else {
fs/xfs/xfs_aops.c +47 -24
108 lines not on this page · raw message
fs/xfs/xfs_bmap_util.c +69 -24
128 lines not on this page · raw message
fs/xfs/xfs_buf_item.c +90 -47
212 lines not on this page · raw message
fs/xfs/xfs_buf_item.h +4 -1
@@ -64,12 +64,15 @@ typedef struct xfs_buf_log_item {int xfs_buf_item_init (struct xfs_buf *,struct xfs_mount *);void xfs_buf_item_relse (struct xfs_buf *);void xfs_buf_item_log (xfs_buf_log_item_t *,uint ,uint ); -uint xfs_buf_item_dirty (xfs_buf_log_item_t *); +bool xfs_buf_item_dirty_format (struct xfs_buf_log_item *);void xfs_buf_attach_iodone (struct xfs_buf *,void (*)(struct xfs_buf *,xfs_log_item_t *),xfs_log_item_t *);void xfs_buf_iodone_callbacks (struct xfs_buf *);void xfs_buf_iodone (struct xfs_buf *,struct xfs_log_item *); +bool xfs_buf_resubmit_failed_buffers (struct xfs_buf *, +struct xfs_log_item *, +struct list_head *);extern kmem_zone_t *xfs_buf_item_zone;
fs/xfs/xfs_icache.c +5 -5
@@ -1124,11 +1124,11 @@ xfs_reclaim_inode(* Because we use RCU freeing we need to ensure the inode always appears * to be reclaimed with an invalid inode number when in the free state. * We do this as early as possible under the ILOCK so that -* xfs_iflush_cluster() can be guaranteed to detect races with us here. -* By doing this, we guarantee that once xfs_iflush_cluster has locked -* XFS_ILOCK that it will see either a valid, flushable inode that will -* serialise correctly, or it will see a clean (and invalid) inode that -* it can skip. +* xfs_iflush_cluster() and xfs_ifree_cluster() can be guaranteed to +* detect races with us here. By doing this, we guarantee that once +* xfs_iflush_cluster() or xfs_ifree_cluster() has locked XFS_ILOCK that +* it will see either a valid inode that will serialise correctly, or it +* will see an invalid inode that it can skip. */ spin_lock (&ip->i_flags_lock); ip->i_flags =XFS_IRECLAIM ;
fs/xfs/xfs_inode.c +18 -5
@@ -2359,11 +2359,24 @@ xfs_ifree_cluster(* already marked stale. If we can't lock it, back off * and retry. */ -if (ip != free_ip && - !xfs_ilock_nowait (ip,XFS_ILOCK_EXCL )) { -rcu_read_unlock (); -delay (1 ); - goto retry; +if (ip != free_ip) { +if (!xfs_ilock_nowait (ip,XFS_ILOCK_EXCL )) { +rcu_read_unlock (); +delay (1 ); + goto retry; + } + +/* +* Check the inode number again in case we're +* racing with freeing in xfs_reclaim_inode(). +* See the comments in that function for more +* information as to why the initial check is +* not sufficient. +*/ +if (ip->i_ino != inum + i) { +xfs_iunlock (ip,XFS_ILOCK_EXCL ); +continue ; + } }rcu_read_unlock ();
fs/xfs/xfs_inode_item.c +43 -4
95 lines not on this page · raw message
fs/xfs/xfs_ioctl.c +27 -14
86 lines not on this page · raw message
fs/xfs/xfs_iops.c +1 -1
@@ -817,7 +817,7 @@ xfs_vn_setattr_nonsize(* Caution: The caller of this function is responsible for calling * setattr_prepare() or otherwise verifying the change is fine. */ -int +STATIC intxfs_setattr_size (struct xfs_inode *ip,struct iattr *iattr)
fs/xfs/xfs_log.c +24 -9
@@ -743,10 +743,14 @@ xfs_log_mount_finish( struct xfs_mount *mp) {int error =0 ; +bool readonly = (mp->m_flags &XFS_MOUNT_RDONLY );if (mp->m_flags &XFS_MOUNT_NORECOVERY ) {ASSERT (mp->m_flags &XFS_MOUNT_RDONLY );return 0 ; + }else if (readonly) { +/* Allow unlinked processing to proceed */ + mp->m_flags &= ~XFS_MOUNT_RDONLY ; }/*
@@ -757,12 +761,27 @@ xfs_log_mount_finish(* inodes. Turn it off immediately after recovery finishes * so that we don't leak the quota inodes if subsequent mount * activities fail. +* +* We let all inodes involved in redo item processing end up on +* the LRU instead of being evicted immediately so that if we do +* something to an unlinked inode, the irele won't cause +* premature truncation and freeing of the inode, which results +* in log recovery failure. We have to evict the unreferenced +* lru inodes after clearing MS_ACTIVE because we don't +* otherwise clean up the lru if there's a subsequent failure in +* xfs_mountfs, which leads to us leaking the inodes if nothing +* else (e.g. quotacheck) references the inodes before the +* mount failure occurs. */ mp->m_super->s_flags |=MS_ACTIVE ; error =xlog_recover_finish (mp->m_log);if (!error)xfs_log_work_queue (mp); mp->m_super->s_flags &= ~MS_ACTIVE ; +evict_inodes (mp->m_super); + +if (readonly) + mp->m_flags |=XFS_MOUNT_RDONLY ;return error; }
@@ -812,11 +831,14 @@ xfs_log_unmount_write(xfs_mount_t *mp)int error;/* -* Don't write out unmount record on read-only mounts. +* Don't write out unmount record on norecovery mounts or ro devices. * Or, if we are doing a forced umount (typically because of IO errors). */ -if (mp->m_flags &XFS_MOUNT_RDONLY ) +if (mp->m_flags &XFS_MOUNT_NORECOVERY || +xfs_readonly_buftarg (log->l_mp->m_logdev_targp)) { +ASSERT (mp->m_flags &XFS_MOUNT_RDONLY );return 0 ; + } error =_xfs_log_force (mp,XFS_LOG_SYNC ,NULL );ASSERT (error || !(XLOG_FORCED_SHUTDOWN (log)));
@@ -3353,8 +3375,6 @@ _xfs_log_force(*/ if (iclog->ic_state &XLOG_STATE_IOERROR )return -EIO ; -if (log_flushed) - *log_flushed =1 ; }else { no_sleep:
@@ -3458,8 +3478,6 @@ _xfs_log_force_lsn(xlog_wait (&iclog->ic_prev->ic_write_wait, &log->l_icloglock); -if (log_flushed) - *log_flushed =1 ; already_slept =1 ; goto try_again; }
@@ -3493,9 +3511,6 @@ _xfs_log_force_lsn(*/ if (iclog->ic_state &XLOG_STATE_IOERROR )return -EIO ; - -if (log_flushed) - *log_flushed =1 ; }else {/* just return */ spin_unlock (&log->l_icloglock); }
fs/xfs/xfs_log_recover.c +99 -60
240 lines not on this page · raw message
fs/xfs/xfs_super.c +1 -1
@@ -1220,7 +1220,7 @@ xfs_test_remount_options( tmp_mp->m_super = sb; error =xfs_parseargs (tmp_mp, options);xfs_free_fsname (tmp_mp); -kfree (tmp_mp); +kmem_free (tmp_mp);return error; }
fs/xfs/xfs_trace.h +0 -1
@@ -517,7 +517,6 @@ DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size);DEFINE_BUF_ITEM_EVENT (xfs_buf_item_size_ordered);DEFINE_BUF_ITEM_EVENT (xfs_buf_item_size_stale);DEFINE_BUF_ITEM_EVENT (xfs_buf_item_format); -DEFINE_BUF_ITEM_EVENT (xfs_buf_item_format_ordered);DEFINE_BUF_ITEM_EVENT (xfs_buf_item_format_stale);DEFINE_BUF_ITEM_EVENT (xfs_buf_item_ordered);DEFINE_BUF_ITEM_EVENT (xfs_buf_item_pin);
fs/xfs/xfs_trans.h +10 -4
@@ -49,6 +49,7 @@ typedef struct xfs_log_item {struct xfs_ail *li_ailp;/* ptr to AIL */ uint li_type;/* item type */ uint li_flags;/* misc flags */ +struct xfs_buf *li_buf;/* real buffer pointer */ struct xfs_log_item *li_bio_list;/* buffer item list */ void (*li_cb)(struct xfs_buf *,struct xfs_log_item *);
@@ -64,11 +65,13 @@ typedef struct xfs_log_item { } xfs_log_item_t;#define XFS_LI_IN_AIL 0x1 -#define XFS_LI_ABORTED 0x2 +#define XFS_LI_ABORTED 0x2 +#define XFS_LI_FAILED 0x4#define XFS_LI_FLAGS \ { XFS_LI_IN_AIL, "IN_AIL" }, \ - { XFS_LI_ABORTED, "ABORTED" } + { XFS_LI_ABORTED, "ABORTED" }, \ + { XFS_LI_FAILED, "FAILED" }struct xfs_item_ops {void (*iop_size)(xfs_log_item_t *,int *,int *);
@@ -79,6 +82,7 @@ struct xfs_item_ops {void (*iop_unlock)(xfs_log_item_t *);xfs_lsn_t (*iop_committed)(xfs_log_item_t *,xfs_lsn_t );void (*iop_committing)(xfs_log_item_t *,xfs_lsn_t ); +void (*iop_error)(xfs_log_item_t *,xfs_buf_t *); }; void xfs_log_item_init(struct xfs_mount *mp, struct xfs_log_item *item,
@@ -208,12 +212,14 @@ void xfs_trans_bhold_release(xfs_trans_t *, struct xfs_buf *);void xfs_trans_binval (xfs_trans_t *,struct xfs_buf *);void xfs_trans_inode_buf (xfs_trans_t *,struct xfs_buf *);void xfs_trans_stale_inode_buf (xfs_trans_t *,struct xfs_buf *); -void xfs_trans_ordered_buf (xfs_trans_t *,struct xfs_buf *); +bool xfs_trans_ordered_buf (xfs_trans_t *,struct xfs_buf *);void xfs_trans_dquot_buf (xfs_trans_t *,struct xfs_buf *,uint );void xfs_trans_inode_alloc_buf (xfs_trans_t *,struct xfs_buf *);void xfs_trans_ichgtime (struct xfs_trans *,struct xfs_inode *,int );void xfs_trans_ijoin (struct xfs_trans *,struct xfs_inode *,uint ); -void xfs_trans_log_buf (xfs_trans_t *,struct xfs_buf *,uint ,uint ); +void xfs_trans_log_buf (struct xfs_trans *,struct xfs_buf *,uint , +uint ); +void xfs_trans_dirty_buf (struct xfs_trans *,struct xfs_buf *);void xfs_trans_log_inode (xfs_trans_t *,struct xfs_inode *,uint );void xfs_extent_free_init_defer_op (void );
fs/xfs/xfs_trans_ail.c +2 -1
@@ -687,12 +687,13 @@ xfs_trans_ail_update_bulk(bool xfs_ail_delete_one (struct xfs_ail *ailp, -struct xfs_log_item *lip) +struct xfs_log_item *lip) {struct xfs_log_item *mlip =xfs_ail_min (ailp);trace_xfs_ail_delete (lip, mlip->li_lsn, lip->li_lsn);xfs_ail_delete (ailp, lip); +xfs_clear_li_failed (lip); lip->li_flags &= ~XFS_LI_IN_AIL ; lip->li_lsn =0 ;
fs/xfs/xfs_trans_buf.c +49 -30
128 lines not on this page · raw message
fs/xfs/xfs_trans_priv.h +31 -0
@@ -164,4 +164,35 @@ xfs_trans_ail_copy_lsn( *dst = *src; }#endif + +static inline void +xfs_clear_li_failed ( +struct xfs_log_item *lip) +{ +struct xfs_buf *bp = lip->li_buf; + +ASSERT (lip->li_flags &XFS_LI_IN_AIL ); +lockdep_assert_held (&lip->li_ailp->xa_lock); + +if (lip->li_flags &XFS_LI_FAILED ) { + lip->li_flags &= ~XFS_LI_FAILED ; + lip->li_buf =NULL ; +xfs_buf_rele (bp); + } +} + +static inline void +xfs_set_li_failed ( +struct xfs_log_item *lip, +struct xfs_buf *bp) +{ +lockdep_assert_held (&lip->li_ailp->xa_lock); + +if (!(lip->li_flags &XFS_LI_FAILED )) { +xfs_buf_hold (bp); + lip->li_flags |=XFS_LI_FAILED ; + lip->li_buf = bp; + } +} +#endif /* __XFS_TRANS_PRIV_H__ */
include/linux/fs.h +1 -0
@@ -2831,6 +2831,7 @@ static inline void lockdep_annotate_inode_mutex_key(struct inode *inode) { };#endif extern void unlock_new_inode (struct inode *);extern unsigned int get_next_ino (void ); +extern void evict_inodes (struct super_block *sb);extern void __iget (struct inode * inode);extern void iget_failed (struct inode *);
include/linux/mm_inline.h +6 -0
@@ -126,4 +126,10 @@ static __always_inline enum lru_list page_lru(struct page *page)#define lru_to_page (head) (list_entry((head)->prev, struct page, lru)) +#ifdef arch_unmap_kpfn +extern void arch_unmap_kpfn (unsigned long pfn); +#else +static __always_inline void arch_unmap_kpfn(unsigned long pfn) { } +#endif +#endif
include/linux/skbuff.h +1 -1
@@ -885,7 +885,7 @@ void kfree_skb(struct sk_buff *skb);void kfree_skb_list (struct sk_buff *segs);void skb_tx_error (struct sk_buff *skb);void consume_skb (struct sk_buff *skb); -void consume_stateless_skb (struct sk_buff *skb); +void __consume_stateless_skb (struct sk_buff *skb);void __kfree_skb (struct sk_buff *skb);extern struct kmem_cache *skbuff_head_cache;
include/net/inet_frag.h +9 -26
@@ -1,14 +1,9 @@ #ifndef __NET_FRAG_H__ #define __NET_FRAG_H__ -#include <linux/percpu_counter.h> - struct netns_frags { - /* The percpu_counter "mem" need to be cacheline aligned. - * mem.count must not share cacheline with other writers - */ - struct percpu_counter mem ____cacheline_aligned_in_smp; - + /* Keep atomic mem on separate cachelines in structs that include it */ + atomic_t mem ____cacheline_aligned_in_smp; /* sysctls */ int timeout; int high_thresh;
@@ -108,15 +103,10 @@ struct inet_frags {int inet_frags_init (struct inet_frags *);void inet_frags_fini (struct inet_frags *); -static inline int inet_frags_init_net (struct netns_frags *nf) -{ -return percpu_counter_init (&nf->mem,0 ,GFP_KERNEL ); -} -static inline void inet_frags_uninit_net (struct netns_frags *nf) +static inline void inet_frags_init_net (struct netns_frags *nf) { -percpu_counter_destroy (&nf->mem); +atomic_set (&nf->mem,0 ); } -void inet_frags_exit_net (struct netns_frags *nf,struct inet_frags *f);void inet_frag_kill (struct inet_frag_queue *q,struct inet_frags *f);
@@ -140,31 +130,24 @@ static inline bool inet_frag_evicting(struct inet_frag_queue *q)/* Memory Tracking Functions. */ -/* The default percpu_counter batch size is not big enough to scale to -* fragmentation mem acct sizes. -* The mem size of a 64K fragment is approx: -* (44 fragments * 2944 truesize) + frag_queue struct(200) = 129736 bytes -*/ -static unsigned int frag_percpu_counter_batch =130000 ; -static inline int frag_mem_limit (struct netns_frags *nf) { -return percpu_counter_read (&nf->mem); +return atomic_read (&nf->mem); }static inline void sub_frag_mem_limit (struct netns_frags *nf,int i) { -percpu_counter_add_batch (&nf->mem, -i, frag_percpu_counter_batch); +atomic_sub (i, &nf->mem); }static inline void add_frag_mem_limit (struct netns_frags *nf,int i) { -percpu_counter_add_batch (&nf->mem, i, frag_percpu_counter_batch); +atomic_add (i, &nf->mem); } -static inline unsigned int sum_frag_mem_limit (struct netns_frags *nf) +static inline int sum_frag_mem_limit (struct netns_frags *nf) { -return percpu_counter_sum_positive (&nf->mem); +return atomic_read (&nf->mem); }/* RFC 3168 support :
lib/idr.c +1 -1
@@ -154,7 +154,7 @@ void *idr_replace(struct idr *idr, void *ptr, int id)void __rcu **slot =NULL ;void *entry; -if (WARN_ON_ONCE (id <0 )) +if (id <0 )return ERR_PTR (-EINVAL );if (WARN_ON_ONCE (radix_tree_is_internal_node (ptr)))return ERR_PTR (-EINVAL );
mm/memory-failure.c +2 -0
@@ -1146,6 +1146,8 @@ int memory_failure(unsigned long pfn, int trapno, int flags)return 0 ; } +arch_unmap_kpfn (pfn); + orig_head = hpage =compound_head (p);num_poisoned_pages_inc ();
net/core/skbuff.c +3 -6
@@ -753,14 +753,11 @@ EXPORT_SYMBOL(consume_skb);* consume_stateless_skb - free an skbuff, assuming it is stateless * @skb: buffer to free * -* Works like consume_skb(), but this variant assumes that all the head -* states have been already dropped. +* Alike consume_skb(), but this variant assumes that this is the last +* skb reference and all the head states have been already dropped */ -void consume_stateless_skb (struct sk_buff *skb) +void __consume_stateless_skb (struct sk_buff *skb) { -if (!skb_unref (skb)) -return ; -trace_consume_skb (skb);if (likely (skb->head))skb_release_data (skb);
net/ieee802154/6lowpan/reassembly.c +3 -8
@@ -580,19 +580,14 @@ static int __net_init lowpan_frags_init_net(struct net *net) {struct netns_ieee802154_lowpan *ieee802154_lowpan =net_ieee802154_lowpan (net); -int res; ieee802154_lowpan->frags.high_thresh =IPV6_FRAG_HIGH_THRESH ; ieee802154_lowpan->frags.low_thresh =IPV6_FRAG_LOW_THRESH ; ieee802154_lowpan->frags.timeout =IPV6_FRAG_TIMEOUT ; - res =inet_frags_init_net (&ieee802154_lowpan->frags); -if (res) -return res; - res =lowpan_frags_ns_sysctl_register (net); -if (res) -inet_frags_uninit_net (&ieee802154_lowpan->frags); -return res; +inet_frags_init_net (&ieee802154_lowpan->frags); + +return lowpan_frags_ns_sysctl_register (net); } static void __net_exit lowpan_frags_exit_net(struct net *net)
net/ipv4/inet_fragment.c +1 -3
@@ -234,10 +234,8 @@ void inet_frags_exit_net(struct netns_frags *nf, struct inet_frags *f)cond_resched ();if (read_seqretry (&f->rnd_seqlock, seq) || -percpu_counter_sum (&nf->mem)) +sum_frag_mem_limit (nf)) goto evict_again; - -percpu_counter_destroy (&nf->mem); }EXPORT_SYMBOL (inet_frags_exit_net);
net/ipv4/ip_fragment.c +3 -9
@@ -844,8 +844,6 @@ static void __init ip4_frags_ctl_register(void)static int __net_init ipv4_frags_init_net (struct net *net) { -int res; -/* Fragment cache limits. * * The fragment memory accounting code, (tries to) account for
@@ -871,13 +869,9 @@ static int __net_init ipv4_frags_init_net(struct net *net) net->ipv4.frags.max_dist =64 ; - res =inet_frags_init_net (&net->ipv4.frags); -if (res) -return res; - res =ip4_frags_ns_ctl_register (net); -if (res) -inet_frags_uninit_net (&net->ipv4.frags); -return res; +inet_frags_init_net (&net->ipv4.frags); + +return ip4_frags_ns_ctl_register (net); } static void __net_exit ipv4_frags_exit_net(struct net *net)
net/ipv4/ip_tunnel.c +2 -2
@@ -618,8 +618,8 @@ void ip_md_tunnel_xmit(struct sk_buff *skb, struct net_device *dev, u8 proto)ip_rt_put (rt); goto tx_dropped; } -iptunnel_xmit (NULL , rt, skb, fl4.saddr, fl4.daddr, proto, key->tos, - key->ttl, df, !net_eq (tunnel->net,dev_net (dev))); +iptunnel_xmit (NULL , rt, skb, fl4.saddr, fl4.daddr, proto, tos, ttl, + df, !net_eq (tunnel->net,dev_net (dev)));return ; tx_error: dev->stats.tx_errors++;
net/ipv4/tcp_ipv4.c +3 -3
@@ -1722,9 +1722,9 @@ int tcp_v4_rcv(struct sk_buff *skb)*/ sock_hold (sk); refcounted = true; -if (tcp_filter (sk, skb)) - goto discard_and_relse; - nsk =tcp_check_req (sk, skb, req, false); + nsk =NULL ; +if (!tcp_filter (sk, skb)) + nsk =tcp_check_req (sk, skb, req, false);if (!nsk) {reqsk_put (req); goto discard_and_relse;
net/ipv4/udp.c +4 -1
@@ -1386,12 +1386,15 @@ void skb_consume_udp(struct sock *sk, struct sk_buff *skb, int len)unlock_sock_fast (sk, slow); } +if (!skb_unref (skb)) +return ; +/* In the more common cases we cleared the head states previously, * see __udp_queue_rcv_skb(). */ if (unlikely (udp_skb_has_head_state (skb)))skb_release_head_state (skb); -consume_stateless_skb (skb); +__consume_stateless_skb (skb); }EXPORT_SYMBOL_GPL (skb_consume_udp);
net/ipv6/ip6_fib.c +19 -6
@@ -198,6 +198,12 @@ static void rt6_release(struct rt6_info *rt) } } +static void fib6_free_table (struct fib6_table *table) +{ +inetpeer_invalidate_tree (&table->tb6_peers); +kfree (table); +} +static void fib6_link_table (struct net *net,struct fib6_table *tb) {unsigned int h;
@@ -1915,15 +1921,22 @@ static int __net_init fib6_net_init(struct net *net)static void fib6_net_exit (struct net *net) { +unsigned int i; +rt6_ifdown (net,NULL );del_timer_sync (&net->ipv6.ip6_fib_timer); -#ifdef CONFIG_IPV6_MULTIPLE_TABLES -inetpeer_invalidate_tree (&net->ipv6.fib6_local_tbl->tb6_peers); -kfree (net->ipv6.fib6_local_tbl); -#endif -inetpeer_invalidate_tree (&net->ipv6.fib6_main_tbl->tb6_peers); -kfree (net->ipv6.fib6_main_tbl); +for (i =0 ; i <FIB6_TABLE_HASHSZ ; i++) { +struct hlist_head *head = &net->ipv6.fib_table_hash[i]; +struct hlist_node *tmp; +struct fib6_table *tb; + +hlist_for_each_entry_safe (tb, tmp, head, tb6_hlist) { +hlist_del (&tb->tb6_hlist); +fib6_free_table (tb); + } + } +kfree (net->ipv6.fib_table_hash);kfree (net->ipv6.rt6_stats); }
net/ipv6/ip6_gre.c +3 -1
@@ -432,7 +432,9 @@ static void ip6gre_err(struct sk_buff *skb, struct inet6_skb_parm *opt, }break ;case ICMPV6_PKT_TOOBIG : - mtu =be32_to_cpu (info) - offset; + mtu =be32_to_cpu (info) - offset - t->tun_hlen; +if (t->dev->type ==ARPHRD_ETHER ) + mtu -=ETH_HLEN ;if (mtu <IPV6_MIN_MTU ) mtu =IPV6_MIN_MTU ; t->dev->mtu = mtu;
net/ipv6/netfilter/nf_conntrack_reasm.c +3 -9
@@ -622,18 +622,12 @@ EXPORT_SYMBOL_GPL(nf_ct_frag6_gather);static int nf_ct_net_init (struct net *net) { -int res; - net->nf_frag.frags.high_thresh =IPV6_FRAG_HIGH_THRESH ; net->nf_frag.frags.low_thresh =IPV6_FRAG_LOW_THRESH ; net->nf_frag.frags.timeout =IPV6_FRAG_TIMEOUT ; - res =inet_frags_init_net (&net->nf_frag.frags); -if (res) -return res; - res =nf_ct_frag6_sysctl_register (net); -if (res) -inet_frags_uninit_net (&net->nf_frag.frags); -return res; +inet_frags_init_net (&net->nf_frag.frags); + +return nf_ct_frag6_sysctl_register (net); }static void nf_ct_net_exit (struct net *net)
net/ipv6/reassembly.c +3 -9
@@ -714,19 +714,13 @@ static void ip6_frags_sysctl_unregister(void)static int __net_init ipv6_frags_init_net (struct net *net) { -int res; - net->ipv6.frags.high_thresh =IPV6_FRAG_HIGH_THRESH ; net->ipv6.frags.low_thresh =IPV6_FRAG_LOW_THRESH ; net->ipv6.frags.timeout =IPV6_FRAG_TIMEOUT ; - res =inet_frags_init_net (&net->ipv6.frags); -if (res) -return res; - res =ip6_frags_ns_sysctl_register (net); -if (res) -inet_frags_uninit_net (&net->ipv6.frags); -return res; +inet_frags_init_net (&net->ipv6.frags); + +return ip6_frags_ns_sysctl_register (net); } static void __net_exit ipv6_frags_exit_net(struct net *net)
net/ipv6/tcp_ipv6.c +3 -3
@@ -1456,9 +1456,9 @@ static int tcp_v6_rcv(struct sk_buff *skb) }sock_hold (sk); refcounted = true; -if (tcp_filter (sk, skb)) - goto discard_and_relse; - nsk =tcp_check_req (sk, skb, req, false); + nsk =NULL ; +if (!tcp_filter (sk, skb)) + nsk =tcp_check_req (sk, skb, req, false);if (!nsk) {reqsk_put (req); goto discard_and_relse;
net/sctp/ulpqueue.c +2 -1
@@ -265,7 +265,8 @@ int sctp_ulpq_tail_event(struct sctp_ulpq *ulpq, struct sctp_ulpevent *event)sctp_ulpq_clear_pd (ulpq);if (queue == &sk->sk_receive_queue && !sp->data_ready_signalled) { - sp->data_ready_signalled =1 ; +if (!sock_owned_by_user (sk)) + sp->data_ready_signalled =1 ; sk->sk_data_ready (sk); }return 1 ;