What are the most common, and serious, database vulnerabilities that businesses should be aware of?
The Top Ten Most Common Database Security Vulnerabilities
How to Create a sysfs File Correctly
One common Linux kernel driver issue that I see all the time is a driver
author attempting to create a sysfs file in their code by doing
something like:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
|
That’s a good first start, until they get tired of adding more and more
sysfs files, and they discover attribute groups, which allows
multiple sysfs files to be created and destroyed all at once,
without having to handle the unwinding of things if problems occur:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
|
And everyone is happy, and things seem to work just fine (oh, you did
document all of these sysfs files in Documentation/ABI/,
right?)
Anyway, one day the developer gets an email saying that for some reason,
userspace can’t see the sysfs files that are being created.
The user is using a library, or udev rule, and the attribute seems to
not exist. This is quite odd, because if you look at sysfs,
the files are there, but yet, libudev doesn’t think it is. What is
going on?
It turns out that the driver is racing with userspace to notice when the
device is being created in sysfs. The driver core, and at a
more basic level, the kobject core below it, announces to userspace when
a new device is created or removed from the system. At that point in
time, tools run to read all of the attributes for the device, and store
them away so that udev rules can run on them, and other libraries can
have access to them.
The problem is, when a driver’s probe() function is called,
userspace has already been told the device is present, so any
sysfs files that are created at this point in time, will
probably be missed entirely.
The driver core has a number of ways that this can be solved, making the
driver author’s job even easier, by allowing “default attributes” to be
created by the driver core before it is announced to userspace.
These default attribute groups exist at lots of different levels in the
driver / device / class hierarchy.
If you have a bus, you can set the following fields in struct
bus:
1 2 3 4 5 6 7 |
|
If you aren’t dealing with a bus, but rather a class, then set these
fields in your struct class:
1 2 3 4 5 6 7 |
|
If you aren’t in control of the bus logic or class logic, but you have
control over the struct device_driver structure, then set this
field:
1 2 3 4 5 |
|
Sometimes you don’t have control over the driver either, or want
different sysfs files for different devices controlled by your
driver (platform_device drivers are like this at times.) Then,
at the least, you have control over the device structure itself. If so,
then use this field:
1 2 3 4 5 |
|
By setting this value, you don’t have to do anything in your
probe() or release() functions at all in order for the
sysfs files to be properly created and destroyed whenever your
device is added or removed from the system. And you will, most
importantly, do it in a race-free manner, which is always a good thing.
Puppet Enterprise 3.0 Offers Better Performance
Puppet is one of the defining configuration management tools in the DevOps field. A new major release of the commercial version is now available with better performance and a wider range of supported systems and functions.
Akademy 2013 Keynote: Jolla’s Vesa-Matti Hartikainen
Dot Categories:
This Akademy keynote talk is based on Jolla and their Sailfish OS. It will cover project history, software architecture and collaboration between Jolla and various open source projects such as Qt, Mer, and Nemo Mobile. It will address the user interface concepts used in Sailfish OS and highlight the benefits of using Qt Quick to build the user experience in Sailfish OS.
Swift: The Easy Scripting Language for Parallel Computing
Over the next decade, computer scientists anticipate the world’s largest supercomputers will grow to millions of cores running as many as a billion parallel threads. Even personal devices will contain a hundred cores and perform thousands of concurrent tasks.
Such systems with the ability to run multiple parts of the same program at the same time – in parallel – on a massive scale will be necessary to solve complex problems like climate change and drug modeling as well as to crunch the exabytes of data our smart devices will collectively produce.
“Parallel computing is the only path forward,” said Andreas Olofsson, founder and CEO of Adapteva, in his talk about the $99 Linux supercomputer Parallela at Collaboration Summit earlier this year. But the industry, in large part, isn’t yet prepared to push it into the mainstream, he said.
Hindering progress is the absence of a high-level programming language, akin to Java or Python, for writing parallel code. Parallel programming is harder to learn than traditional serial programming and has remained a specialized skill that few developers are trained to do.
“It’s much easier to think of algorithms and processes as a number of steps, or a recipe. Everything moves through an order,” Olofsson said in a phone interview with Linux.com. A parallel program doesn’t have an order. “So in your head you have to keep a map of when things are going to happen. That really takes some training and a different way of thinking.”
The problem is even tougher when it comes to helping researchers with basic programming skills attempt to write parallel applications. That’s why it’s common in science and engineering for researchers to run many copies of existing serial applications at once to explore or simulate a phenomena or analyze a big dataset instead of writing a native parallel application, said Michael Wilde, a computer science researcher at Argonne National Laboratory and the University of Chicago. But that approach won’t scale for the million-core datasets of the future.
Bottom line: In order to reach new levels of supercomputing and advance scientific discovery, parallel processing needs to be more accessible to the scientists, engineers, and data analysts that need it. And for that to happen, the use of parallel hardware needs to be far easier for – and ideally transparent to – the programmer.
The Swift Solution
That’s why Wilde and fellow researchers at Argonne and the University of Chicago have developed Swift, a new programming language designed from the ground up for building parallel applications. Similar to a shell script, Swift allows a user to stitch together programs or high-level functions written in any other language, including scripting languages such as Python, R or MATLAB, or even already-parallel programs written in C or FORTRAN using MPI or OpenMP.
Swift plays a simple but “pervasively parallel” coordination role to create the upper level logic of more complex applications, Wilde said. “It makes it very easy to parallelize what we often call the ‘outer loops’.”
Highly parallel applications can thus be composed by gluing together serial algorithms because Swift creates the parallelism automatically at runtime, without explicit direction from the programmer. It does this by first encapsulating the applications that are called within a script as “functions” with uniform interfaces, and then applying automatic data flow, he said.
“This enables Swift to provide transparent distributed parallel computing (e.g. for cloud resources) by automatically marshaling the data that needs to get passed between applications in a way that native Linux shells like “bash” or scripting languages like Python or Ruby can not do by themselves,” Wilde said.
Using a “dataflow-driven” programming model, in which its runtime environment monitors the state of all data elements in the program, Swift decides which parts of a program can run in parallel and what tasks must wait for data to be produced by other parts of the code, he said.
“We’re trying to retain the flavor and power of traditional UNIX scripting but to give it a uniformity that allows for automated parallelization, distribution and error recovery,” Wilde said
A General Purpose Hadoop
Swift is an “intriguing” solution, Olofsson said, because it’s not an entirely new language. It supports existing frameworks to accomplish distributed-scale parallel computing, almost like a general-purpose Hadoop, he said.
But whether it’s Swift or another language, it’s most important for programmers to start learning and using something – anything – in parallel. A standard will emerge over time as more programmers learn parallel programming and converge on a language, Olofsson said.
“The challenge today is, ‘How do you make it so that parallel programming is as productive as Java or Python is?” Olofsson said at Collaboration Summit. “That should be the goal, and not the way it is where a few coding ninjas can make the parallel hardware really sing.
“It should get to the point where there are thousands of projects on github all written in parallel code,” he said, “running on any kind of hardware.”
SolydXK: New Kid on the Linux Block Delivers Rock-Solid Performance
SolydXK is a Debian-based Linux distribution that offers a choice of two desktops: Xfce and KDE. It is a very new Linux OS, but do not push this new kid aside assuming stability and performance need a lot of maturing. In fact, SolydXK is already a solid and very impressive distro. It has more polish and smoother performance than many older Linux OS counterparts. Released in late February by “Schoelje,” a key developer of two discontinued desktop options within the Linux Mint distro, SolydXK picks up where the Linux Mint line leaves off.
Student Cluster Teams Break Records at ISC’13
At the 2013 International Student Cluster Challenge (ISC’13), the team from Huazhong University of Science and Technology (HUST), China, won the Best Linpack award and set a new record with 8.455 Tflops. The team from the Centre for High Performance Computing of South Africa won the Overall Best award, and the team from Tsinghua University ranked second in terms of overall score at ISC’13. It is China’s second championship at ISC’13 after Tianhe-2 claimed the lead in the Top500 list, and attendees were impressed by China’s rapid development in system research, application development, and talent education of supercomputers.
Mint 15 Freshens Ubuntu’s Bad Bits
Slipping between GNOME and Unity sheets with Olivia
Review Mint is a relative newcomer to the world of popular desktop distros, but it has recently started to take the GNOME and Unity-hating Linux world by storm.…
Citrix Open Sources XenServer
With the release of XenServer 6.2, the company has taken the final step to completely open source the Xen virtualisation stack on top of CentOS and is making it available through a new community portal.
50 Community Building Tips from Feverbee

If you’re looking for a few immediately useful actions for community building, here are 50 that might help.
